Java 类org.hamcrest.CoreMatchers 实例源码

@Before
public void startMainActivityFromHomeScreen() {
    // Initialize UiDevice instance
    mDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());

    // Start from the home screen
    mDevice.pressHome();

    // Wait for launcher
    final String launcherPackage = mDevice.getLauncherPackageName();
    Assert.assertThat(launcherPackage, CoreMatchers.notNullValue());
    mDevice.wait(Until.hasObject(By.pkg(launcherPackage).depth(0)),
            LAUNCH_TIMEOUT);

    // Launch the app
    Context context = InstrumentationRegistry.getContext();
    final Intent intent = context.getPackageManager()
            .getLaunchIntentForPackage(BASIC_SAMPLE_PACKAGE);
    // Clear out any previous instances
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
    context.startActivity(intent);

    // Wait for the app to appear
    mDevice.wait(Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
            LAUNCH_TIMEOUT);
}

@Test (timeout = 10000)
public void testWindowsShellScriptBuilderEnv() throws IOException {
  // Test is only relevant on Windows
  Assume.assumeTrue(Shell.WINDOWS);

  // The tests are built on assuming 8191 max command line length
  assertEquals(8191, Shell.WINDOWS_MAX_SHELL_LENGHT);

  ShellScriptBuilder builder = ShellScriptBuilder.create();

  // test env
  builder.env("somekey", org.apache.commons.lang.StringUtils.repeat("A", 1024));
  builder.env("somekey", org.apache.commons.lang.StringUtils.repeat(
      "A", Shell.WINDOWS_MAX_SHELL_LENGHT - ("@set somekey=").length()));
  try {
    builder.env("somekey", org.apache.commons.lang.StringUtils.repeat(
        "A", Shell.WINDOWS_MAX_SHELL_LENGHT - ("@set somekey=").length()) + 1);
    fail("long env was expected to throw");
  } catch(IOException e) {
    assertThat(e.getMessage(), CoreMatchers.containsString(expectedMessage));
  }
}

@Test
public void inputTypeFinder_should_returnClassItself() {
  //GIVEN
  source =
      forSourceString(
          "test.Test",
          "" //
              + "package test;\n" //
              + "import org.gradle.incap.Annotation1;\n" //
              + "@Annotation1\n" //
              + "public class Test {\n" //
              + "}");

  //WHEN
  InputType inputType = findInputTypeSuccessFully(source);

  //THEN
  assertThat(inputType, CoreMatchers.notNullValue());
  assertThat(inputType.getName(), CoreMatchers.is("test.Test"));
}

/**
 * Verify that the given exception event capture (as returned by
 * getAndInitExceptionCapture) has thrown an exception of the given
 * expectedExceptionClass.
 * Resets the capture
 * @param err
 */
void verifyExceptionCaptured(
        OFMessage err, Class<? extends Throwable> expectedExceptionClass) {

    Throwable caughtEx = null;
    // This should purposely cause an exception
    try{
        switchHandler.processOFMessage(err);
    }
    catch(Exception e){
        // Capture the exception
        caughtEx = e;
    }

    assertThat(caughtEx, CoreMatchers.instanceOf(expectedExceptionClass));
}

@Test
public void inputTypeFinder_should_returnClassContainingField() {
  //GIVEN
  source =
      forSourceString(
          "test.Test",
          "" //
              + "package test;\n" //
              + "import org.gradle.incap.Annotation1;\n" //
              + "public class Test {\n" //
              + "  @Annotation1 String foo;\n" //
              + "}");

  //WHEN
  InputType inputType = findInputTypeSuccessFully(source);

  //THEN
  assertThat(inputType, CoreMatchers.notNullValue());
  assertThat(inputType.getName(), CoreMatchers.is("test.Test"));
}

@Test
@UiThreadTest
public void waitForInitialRemoteData_mainThreadThrows() {
    final SyncUser user = SyncTestUtils.createTestUser(Constants.AUTH_URL);
    SyncConfiguration config = new SyncConfiguration.Builder(user, Constants.USER_REALM)
            .waitForInitialRemoteData()
            .build();

    Realm realm = null;
    try {
        realm = Realm.getInstance(config);
        fail();
    } catch (IllegalStateException expected) {
        assertThat(expected.getMessage(), CoreMatchers.containsString(
                "downloadAllServerChanges() cannot be called from the main thread."));
    } finally {
        if (realm != null) {
            realm.close();
        }
    }
}

@Test
public void migrationException_realmListChanged() throws IOException {
    RealmConfiguration config = configFactory.createConfiguration();
    // Initialize the schema with RealmList<Cat>
    Realm.getInstance(configFactory.createConfiguration()).close();

    DynamicRealm dynamicRealm = DynamicRealm.getInstance(config);
    dynamicRealm.beginTransaction();
    // Change the RealmList type to RealmList<Dog>
    RealmObjectSchema dogSchema = dynamicRealm.getSchema().get(Dog.CLASS_NAME);
    RealmObjectSchema ownerSchema = dynamicRealm.getSchema().get(CatOwner.CLASS_NAME);
    ownerSchema.removeField(CatOwner.FIELD_CATS);
    ownerSchema.addRealmListField(CatOwner.FIELD_CATS, dogSchema);
    dynamicRealm.commitTransaction();
    dynamicRealm.close();

    try {
        realm = Realm.getInstance(config);
        fail();
    } catch (RealmMigrationNeededException ignored) {
        assertThat(ignored.getMessage(),
                CoreMatchers.containsString("Property 'CatOwner.cats' has been changed from 'array<Dog>' to 'array<Cat>'"));
    }
}

@Test
public void setRequired_true_onPrimaryKeyField_containsNullValues_shouldThrow() {
    if (type == ObjectSchemaType.IMMUTABLE) {
        return;
    }
    for (PrimaryKeyFieldType fieldType : PrimaryKeyFieldType.values()) {
        String className = fieldType.getType().getSimpleName() + "Class";
        String fieldName = "primaryKey";
        schema = realmSchema.create(className);
        if (!fieldType.isNullable()) {
            continue;
        }
        schema.addField(fieldName, fieldType.getType(), FieldAttribute.PRIMARY_KEY);
        DynamicRealmObject object = ((DynamicRealm)realm).createObject(schema.getClassName(), null);
        assertTrue(object.isNull(fieldName));
        try {
            schema.setRequired(fieldName, true);
            fail();
        } catch (IllegalStateException expected) {
            assertThat(expected.getMessage(),
                    CoreMatchers.containsString("The primary key field 'primaryKey' has 'null' values stored."));
        }
        realmSchema.remove(className);
    }
}

@Test
public void moveToWaitHello() throws Exception {
    resetChannel();
    channel.write(capture(writeCapture));
    expectLastCall().andReturn(null).once();
    replay(channel);
    // replay unused mocks
    replay(messageEvent);

    handler.channelConnected(ctx, channelStateEvent);

    List<OFMessage> msgs = getMessagesFromCapture();
    assertEquals(1, msgs.size());
    assertEquals(OFType.HELLO, msgs.get(0).getType());
    assertThat(handler.getStateForTesting(), CoreMatchers.instanceOf(OFChannelHandler.WaitHelloState.class));
    verifyUniqueXids(msgs);
}

/**
 * Return the same hub.
 * @throws Exception If fails
 */
@Test
public void sameHub() throws Exception {
    final Hub hub = new RtHub(
        new URI("hub.com"),
        "token"
    );
    MatcherAssert.assertThat(
        new RtUsers(
            hub
        ).hub(),
        CoreMatchers.equalTo(
            hub
        )
    );
}

@Before
public void waitForDbCreation() throws Throwable {
    final CountDownLatch latch = new CountDownLatch(1);
    final LiveData<Boolean> databaseCreated = AppDatabase.getInstance(
            InstrumentationRegistry.getTargetContext(), new AppExecutors())
            .getDatabaseCreated();
    mActivityRule.runOnUiThread(new Runnable() {
        @Override
        public void run() {
            databaseCreated.observeForever(new Observer<Boolean>() {
                @Override
                public void onChanged(@Nullable Boolean aBoolean) {
                    if (Boolean.TRUE.equals(aBoolean)) {
                        databaseCreated.removeObserver(this);
                        latch.countDown();
                    }
                }
            });
        }
    });
    MatcherAssert.assertThat("database should've initialized",
            latch.await(1, TimeUnit.MINUTES), CoreMatchers.is(true));
}

/**
 * Return the same user.
 * @throws Exception If fails
 */
@Test
public void sameUser() throws Exception {
    final Request req = new JdkRequest("");
    final RtUsers users = new RtUsers(
        req,
        new RtHub(
            req
        )
    );
    MatcherAssert.assertThat(
        new RtUser(
            req,
            users,
            "me"
        ).users(),
        CoreMatchers.equalTo(
            users
        )
    );
}

/**
 * Returns a {@link Matcher} that checks if the field contains the provided
 * types as a JSON Array.
 *
 * @param  types the types to match
 * @return a matcher for a type JSON Array
 * @review
 */
public static Matcher<? extends JsonElement> containsTheTypes(
    String... types) {

    Stream<String> stream = Arrays.stream(types);

    List<Matcher<? super JsonElement>> matchers = stream.map(
        CoreMatchers::equalTo
    ).map(
        JsonMatchers::aJsonString
    ).collect(
        Collectors.toList()
    );

    return is(aJsonArrayThat(contains(matchers)));
}

/** Move the channel from scratch to WAIT_FEATURES_REPLY state
 * Builds on moveToWaitHello()
 * adds testing for WAIT_HELLO state
 */
@Test
public void moveToWaitFeaturesReply() throws Exception {
    moveToWaitHello();
    resetChannel();
    channel.write(capture(writeCapture));
    expectLastCall().andReturn(null).atLeastOnce();
    replay(channel);

    OFMessage hello = factory.buildHello().build();
    sendMessageToHandlerWithControllerReset(ImmutableList.<OFMessage>of(hello));

    List<OFMessage> msgs = getMessagesFromCapture();
    assertEquals(1, msgs.size());
    assertEquals(OFType.FEATURES_REQUEST, msgs.get(0).getType());
    verifyUniqueXids(msgs);

    assertThat(handler.getStateForTesting(), CoreMatchers.instanceOf(OFChannelHandler.WaitFeaturesReplyState.class));
}

@Test
public void testPull_unknownBlob() throws RegistryException, IOException, DigestException {
  DescriptorDigest nonexistentDigest =
      DescriptorDigest.fromHash(
          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

  try {
    RegistryClient registryClient = new RegistryClient(null, "localhost:5000", "busybox");
    registryClient.pullBlob(nonexistentDigest, Mockito.mock(Path.class));
    Assert.fail("Trying to pull nonexistent blob should have errored");

  } catch (RegistryErrorException ex) {
    Assert.assertThat(
        ex.getMessage(),
        CoreMatchers.containsString(
            "pull BLOB for localhost:5000/busybox with digest " + nonexistentDigest));
  }
}

@Test
public void testHandleHttpResponseException_badAuthenticationMethod()
    throws HttpResponseException {
  String authenticationMethod = "bad authentication method";

  Mockito.when(mockHttpResponseException.getStatusCode())
      .thenReturn(HttpStatusCodes.STATUS_CODE_UNAUTHORIZED);
  Mockito.when(mockHttpResponseException.getHeaders()).thenReturn(mockHeaders);
  Mockito.when(mockHeaders.getAuthenticate()).thenReturn(authenticationMethod);

  try {
    testAuthenticationMethodRetriever.handleHttpResponseException(mockHttpResponseException);
    Assert.fail(
        "Authentication method retriever should fail if 'WWW-Authenticate' header failed to parse");

  } catch (RegistryErrorException ex) {
    Assert.assertThat(
        ex.getMessage(),
        CoreMatchers.containsString(
            "Failed get authentication method from 'WWW-Authenticate' header"));
  }
}

@Test
public void shouldAddBuildInfoToBuilder() throws Exception {
    DmBuildInfo dmBuildInfo = new DmBuildInfo("name","env","project");

    Info.Builder builder = new Info.Builder();
    dmBuildInfo.contribute(builder);


    Map<String,Object> buildInfo = new HashMap<>();
    buildInfo.put("environment", "env");
    buildInfo.put("project", "project");
    buildInfo.put("name", "name");
    buildInfo.put("version", "unknown");
    buildInfo.put("date", "unknown");
    buildInfo.put("commit", "unknown");
    buildInfo.put("extra", Collections.EMPTY_MAP);

    Map<String,Object> map = new HashMap<>();
    map.put("buildInfo",buildInfo);

    Info info = builder.build();

    assertThat(info.getDetails(), CoreMatchers.equalTo(map));
}

public void testLonLatArrayArrayStored() throws Exception {
    XContentBuilder xContentBuilder = XContentFactory.jsonBuilder().startObject().startObject("type")
        .startObject("properties").startObject("point").field("type", "geo_point");
    String mapping = xContentBuilder.field("store", true).field("doc_values", false).endObject().endObject()
        .endObject().endObject().string();
    DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser().parse("type", new CompressedXContent(mapping));

    ParsedDocument doc = defaultMapper.parse("test", "type", "1", XContentFactory.jsonBuilder()
            .startObject()
            .startArray("point")
            .startArray().value(1.3).value(1.2).endArray()
            .startArray().value(1.5).value(1.4).endArray()
            .endArray()
            .endObject()
            .bytes());

    assertThat(doc.rootDoc().getFields("point"), notNullValue());
    assertThat(doc.rootDoc().getFields("point").length, CoreMatchers.equalTo(4));
}

@Test
public void testRegisterAndCreateForType() {
    // given
    Class<TypeCreatorServiceTest> type = TypeCreatorServiceTest.class;
    TypeCreator creator = new TypeCreator() {
        @Override
        public Object newInstance() {
            return new TypeCreatorServiceTest();
        }
    };

    // when
    service.register(type, creator);
    Object forType = service.createForType(this, type);

    // then
    Assert.assertThat(forType, CoreMatchers.is(CoreMatchers.notNullValue()));
    Assert.assertTrue(forType.getClass() == type);
}

@Test
public void should_return_wrap_in_transaction_runner() throws Exception {
    QueueConsumer queueConsumer = mock(QueueConsumer.class);
    QueueSettings settings = QueueSettings.builder().withBetweenTaskTimeout(Duration.ZERO).withNoTaskTimeout(Duration.ZERO)
            .withProcessingMode(ProcessingMode.WRAP_IN_TRANSACTION).build();
    QueueLocation location = QueueLocation.builder().withTableName("testTable")
            .withQueueId(new QueueId("testQueue")).build();
    when(queueConsumer.getQueueConfig()).thenReturn(new QueueConfig(location, settings));

    QueueRunner queueRunner = QueueRunner.Factory.createQueueRunner(queueConsumer,
            new QueueDao(new QueueShardId("s1"), mock(JdbcOperations.class), mock(TransactionOperations.class)),
            mock(TaskLifecycleListener.class),
            null);

    assertThat(queueRunner, CoreMatchers.instanceOf(QueueRunnerInTransaction.class));
}

@Test
public void setPixel() throws Exception {
    PixelHandler pixelHandler = PixelHandler.getBuilder()
        .buildChannel0().setDimention(10,10).add()
        .buildChannel1().add()
        .instance();

    PixelChannel pixelChannel = pixelHandler.getPixelChannel(0);

    assertThat("Should have 100 pixels",pixelChannel.getLedCount(), CoreMatchers.equalTo(100));

    for (float i = 0; i < 10; i++) {
        int value = (int)(255 - (i*25.5F));
        pixelChannel.setPixel((int)i,0,Pixel.fromColor(value,value,value,value));
    }

    assertThat("Should have 255 at pixels 0",pixelChannel.getPixel(0,0).rawColor, CoreMatchers.equalTo(0xFFFFFFFF));
    assertThat("Should have 255 at pixels 0",pixelChannel.getPixel(9,0).rawColor, CoreMatchers.equalTo(0x19191919));

    pixelChannel.rightShiftPixelsRow(0);

    assertThat("Should have 255 at pixels 0",pixelChannel.getPixel(0,0).rawColor, CoreMatchers.equalTo(0x19191919));
    assertThat("Should have 255 at pixels 0",pixelChannel.getPixel(9,0).rawColor, CoreMatchers.equalTo(0x33333333));
}

@Test
public void testCreateDocument1() throws Exception {
    Pojo1 p = new Pojo1();
    p.id = "foo";
    p.title = "title";
    p.content = "content";
    p.someInternalData = UUID.randomUUID().toString();
    p.categories = new HashSet<>(Arrays.asList("cat1", "cat2", "cat3"));
    p.tax = new Taxonomy("id-1","term 1", Arrays.asList("first Term","term 1", "term one"));

    final Document doc = AnnotationUtil.createDocument(p);
    assertThat("id", doc.getId(), equalTo(p.id));
    assertThat("type", doc.getType(), equalTo("Pojo"));

    assertThat("title", doc.getValue("title"), allOf(instanceOf(String.class), CoreMatchers.<Object>equalTo(p.title)));
    assertThat("content", doc.getValue("data"), allOf(instanceOf(String.class), equalTo(p.content)));
    assertFalse("someInternalData", doc.hasValue("someInternalData"));

    assertThat("categories", doc.getValue("cats"), instanceOf(Collection.class));
}

/**
 * Self get return correct user.
 * @throws Exception If fails
 */
@Test
public void selfGet() throws Exception {
    final Request req = new JdkRequest("");
    final RtUsers users = new RtUsers(
        req,
        new RtHub(
            req
        )
    );
    MatcherAssert.assertThat(
        users.self(),
        CoreMatchers.equalTo(
            new RtUser(
                req.uri().path("/users").back(),
                users,
                "me"
            )
        )
    );
}

/** Move the channel from scratch to WAIT_FEATURES_REPLY state
 * Builds on moveToWaitHello()
 * adds testing for WAIT_HELLO state
 */
@Test
public void moveToWaitFeaturesReply() throws Exception {

    moveToWaitHello();

    resetChannel();
    expect(channel.writeAndFlush(capture(writeCapture))).andReturn(null).atLeastOnce();
    replay(channel);

    OFMessage hello = factory.buildHello().build();
    sendMessageToHandlerWithControllerReset(ImmutableList.<OFMessage>of(hello));

    List<OFMessage> msgs = getMessagesFromCapture();
    assertEquals(1, msgs.size());
    assertEquals(OFType.FEATURES_REQUEST, msgs.get(0).getType());
    verifyUniqueXids(msgs);

    assertThat(handler.getStateForTesting(), CoreMatchers.instanceOf(OFChannelHandler.WaitFeaturesReplyState.class));
}

/** Move channel from scratch to WAIT_INITIAL_STATE, then MASTER,
 * then SLAVE for cases where the switch does not support roles.
 * I.e., the final SLAVE transition should disconnect the switch.
 */
@Test
public void testNoRoleInitialToMasterToSlave() throws Exception {
    int xid = 46;
    // First, lets move the state to MASTER without role support
    testInitialMoveToMasterNoRole();
    assertThat(switchHandler.getStateForTesting(),
            CoreMatchers.instanceOf(OFSwitchHandshakeHandler.MasterState.class));

    assertThat("Unexpected messages have been captured",
            connection.getMessages(),
             Matchers.empty());

    // try to set master role again. should be a no-op
    setupSwitchRoleChangeUnsupported(xid, OFControllerRole.ROLE_MASTER);
    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.MasterState.class));

    assertThat("Unexpected messages have been captured",
            connection.getMessages(),
             Matchers.empty());

    setupSwitchRoleChangeUnsupported(xid, OFControllerRole.ROLE_SLAVE);
    assertThat(connection.isConnected(), equalTo(false));

    assertThat("Unexpected messages have been captured",
            connection.getMessages(),
             Matchers.empty());
}

@Test
public void testHarnessClassLoaderFail() throws Exception {
    try {
        PayloadsTest.testPayload(ExecMockPayload.class, new Class[0]);
        Assert.fail("should have failed");
    } catch (AssertionError e) {
        Assert.assertThat(e.getMessage(), CoreMatchers.containsString("ClassNotFoundException"));
    }
}

/**
 * Move the channel from scratch to WAIT_INITIAL_ROLE state via
 * WAIT_SWITCH_DRIVER_SUB_HANDSHAKE
 * Does extensive testing for the WAIT_SWITCH_DRIVER_SUB_HANDSHAKE state
 *
 */
@Test
public void testSwitchDriverSubHandshake()
        throws Exception {
    moveToWaitSwitchDriverSubHandshake();

    //-------------------------------------------------
    //-------------------------------------------------
    // Send a message to the handler, it should be passed to the
    // switch's sub-handshake handling. After this message the
    // sub-handshake will be complete
    // FIXME:LOJI: With Andi's fix for a default Match object we won't
    // need to build/set this match object

    Match match = factory.buildMatch().build();
    OFMessage m = factory.buildFlowRemoved().setMatch(match).build();
    resetToStrict(sw);
    sw.processDriverHandshakeMessage(m);
    expectLastCall().once();
    expect(sw.isDriverHandshakeComplete()).andReturn(true).once();
    replay(sw);

    switchHandler.processOFMessage(m);

    assertThat(switchHandler.getStateForTesting(),
            CoreMatchers.instanceOf(OFSwitchHandshakeHandler.WaitAppHandshakeState.class));
    assertThat("Unexpected message captured", connection.getMessages(), Matchers.empty());
    verify(sw);
}

@Test (timeout = 10000)
public void testWindowsShellScriptBuilderLink() throws IOException {
  // Test is only relevant on Windows
  Assume.assumeTrue(Shell.WINDOWS);

  String linkCmd = "@" +Shell.WINUTILS + " symlink \"\" \"\"";

  // The tests are built on assuming 8191 max command line length
  assertEquals(8191, Shell.WINDOWS_MAX_SHELL_LENGHT);

  ShellScriptBuilder builder = ShellScriptBuilder.create();

  // test link
  builder.link(new Path(org.apache.commons.lang.StringUtils.repeat("A", 1024)),
      new Path(org.apache.commons.lang.StringUtils.repeat("B", 1024)));
  builder.link(
      new Path(org.apache.commons.lang.StringUtils.repeat(
          "E", (Shell.WINDOWS_MAX_SHELL_LENGHT - linkCmd.length())/2)),
      new Path(org.apache.commons.lang.StringUtils.repeat(
          "F", (Shell.WINDOWS_MAX_SHELL_LENGHT - linkCmd.length())/2)));
  try {
    builder.link(
        new Path(org.apache.commons.lang.StringUtils.repeat(
            "X", (Shell.WINDOWS_MAX_SHELL_LENGHT - linkCmd.length())/2 + 1)),
        new Path(org.apache.commons.lang.StringUtils.repeat(
            "Y", (Shell.WINDOWS_MAX_SHELL_LENGHT - linkCmd.length())/2) + 1));
    fail("long link was expected to throw");
  } catch(IOException e) {
    assertThat(e.getMessage(), CoreMatchers.containsString(expectedMessage));
  }
}

/** Move the channel to MASTER state
 * Expects that the channel is in MASTER or SLAVE state.
 *
 */
@SuppressWarnings("unchecked")
public void changeRoleToMasterWithRequest() throws Exception {
    assertTrue("This method can only be called when handler is in " +
            "MASTER or SLAVE role", switchHandler.isHandshakeComplete());

    // Set the role
    long xid = setupSwitchSendRoleRequestAndVerify(true, OFControllerRole.ROLE_MASTER);

    // prepare mocks and inject the role reply message
    reset(sw);
    expect(sw.getOFFactory()).andReturn(factory).anyTimes();
    expect(sw.write(anyObject(OFMessage.class))).andReturn(true).anyTimes();
    expect(sw.write(anyObject(Iterable.class))).andReturn(Collections.EMPTY_LIST).anyTimes();
    expect(sw.getNumTables()).andStubReturn((short)0);
    sw.setAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE, true);
    expectLastCall().once();
    sw.setControllerRole(OFControllerRole.ROLE_MASTER);
    expectLastCall().once();
    expect(sw.getStatus()).andReturn(SwitchStatus.HANDSHAKE).once();
    sw.setStatus(SwitchStatus.MASTER);
    expectLastCall().once();
    expect(sw.getTables()).andReturn(Collections.EMPTY_LIST).once();
    replay(sw);

    reset(switchManager);
    switchManager.switchStatusChanged(sw, SwitchStatus.HANDSHAKE, SwitchStatus.MASTER);
    expectLastCall().once();
    replay(switchManager);

    OFMessage reply = getRoleReply(xid, OFControllerRole.ROLE_MASTER);

    switchHandler.processOFMessage(reply);

    assertThat(switchHandler.getStateForTesting(), CoreMatchers.instanceOf(OFSwitchHandshakeHandler.MasterState.class));
}

public void handleDescStatsAndCreateSwitch() throws Exception {
    // build the stats reply
    OFDescStatsReply sr = createDescriptionStatsReply();

    reset(sw);
    SwitchDescription switchDescription = new SwitchDescription(sr);
    setupSwitchForInstantiationWithReset();
    sw.setPortDescStats(anyObject(OFPortDescStatsReply.class));
    expectLastCall().once();

    expect(sw.getOFFactory()).andReturn(factory).once();
    replay(sw);

    reset(switchManager);
    expect(switchManager.getHandshakePlugins()).andReturn(plugins).anyTimes();
    expect(
           switchManager.getOFSwitchInstance(anyObject(OFConnection.class),
                                          eq(switchDescription),
                                          anyObject(OFFactory.class),
                                          anyObject(DatapathId.class))).andReturn(sw).once();
    expect(switchManager.getNumRequiredConnections()).andReturn(1).anyTimes(); 
    switchManager.switchAdded(sw);
    expectLastCall().once();
    replay(switchManager);

    // send the description stats reply
    switchHandler.processOFMessage(sr);

    OFMessage msg = connection.retrieveMessage();
    assertThat(msg, CoreMatchers.instanceOf(OFTableFeaturesStatsRequest.class));
    verifyUniqueXids(msg);

    verify(sw, switchManager);
}

@Test
@Override
public void moveToWaitAppHandshakeState() throws Exception {
    moveToWaitDescriptionStatReply();
    handleDescStatsAndCreateSwitch(true);
    assertThat(switchHandler.getStateForTesting(),
            CoreMatchers.instanceOf(WaitAppHandshakeState.class));
}

@Test
public void buildSequenceCounterOnly() {
    final byte[] result = IDBuilder.build(new Blueprint(0, 0x22, 0, 0));
    final byte[] sixthByte = new byte[] { result[5] };
    final String expected = "22";
    assertThat(Hex.encodeHexString(sixthByte), CoreMatchers.is(expected));
}

/**
 * RtUser return Request with path.
 * @throws Exception If fails
 */
@Test
public void path() throws Exception {
    final MkContainer container = new MkGrizzlyContainer()
        .next(
            new MkAnswer.Simple(
                HttpURLConnection.HTTP_OK,
                "{\"body\":\"hi\"}"
            )
        ).start();
    new RtUser(
        new JdkRequest(
            container.home()
        ),
        new RtUsers(
            new JdkRequest(
                container.home()
            ),
            new RtHub(
                new JdkRequest(
                    container.home()
                )
            )
        ),
        "101"
    ).json();
    container.stop();
    MatcherAssert.assertThat(
        container.take().uri(),
        CoreMatchers.equalTo(
            new URI("/101")
        )
    );
}

@Test
public void removeAll_outsideTransaction() {
    List<Dog> objectsToRemove = Collections.singletonList(collection.get(0));
    thrown.expect(IllegalStateException.class);
    thrown.expectMessage(CoreMatchers.containsString("Objects can only be removed from inside a write transaction"));
    collection.removeAll(objectsToRemove);
}

@Test
public void testJmxAttributeValidationExceptionElement() throws Exception {
    JmxAttribute attributeName = new JmxAttribute("attr_name");
    JmxAttributeValidationException jmxAttributeValidationException = new JmxAttributeValidationException(
            attributeName);
    assertThat(jmxAttributeValidationException.getAttributeNames(), CoreMatchers.hasItem(attributeName));
}

/**
 * Schema validation should fail if the backlinked column points to a non-existent field in the source class.
 */
@Test
public void migration_backlinkedSourceFieldDoesntExist() throws ClassNotFoundException {
    final String realmName = "backlinks-missingSourceField.realm";
    RealmConfiguration realmConfig = configFactory.createConfigurationBuilder()
            .name(realmName)
            .schema(BacklinksTarget.class, BacklinksSource.class)
            .build();

    // Mock the schema info so the only difference compared with the original schema is that the LinkingObject field
    // points to BacklinksSource.childNotExist.
    OsObjectSchemaInfo targetSchemaInfo = new OsObjectSchemaInfo.Builder("BacklinksTarget", 1, 1)
            .addPersistedProperty("id", RealmFieldType.INTEGER, !Property.PRIMARY_KEY, !Property.INDEXED, Property.REQUIRED)
            .addComputedLinkProperty("parents", "BacklinksSource", "childNotExist" /*"child" is the original value*/)
            .build();
    OsObjectSchemaInfo sourceSchemaInfo = new OsObjectSchemaInfo.Builder("BacklinksSource", 2, 0)
            .addPersistedProperty("name", RealmFieldType.STRING, !Property.PRIMARY_KEY, !Property.INDEXED, !Property.REQUIRED)
            .addPersistedLinkProperty("child", RealmFieldType.OBJECT, "BacklinksTarget")
            .build();
    Map<Class<? extends RealmModel>, OsObjectSchemaInfo> infoMap =
            new HashMap<Class<? extends RealmModel>, OsObjectSchemaInfo>();
    infoMap.put(BacklinksTarget.class, targetSchemaInfo);
    infoMap.put(BacklinksSource.class, sourceSchemaInfo);

    RealmProxyMediator mediator = spy(realmConfig.getSchemaMediator());
    when(mediator.getExpectedObjectSchemaInfoMap()).thenReturn(infoMap);
    RealmConfiguration spyConfig = spy(realmConfig);
    when(spyConfig.getSchemaMediator()).thenReturn(mediator);

    try {
        Realm localRealm = Realm.getInstance(spyConfig);
        localRealm.close();
        fail();
    } catch (IllegalStateException expected) {
        assertThat(expected.getMessage(), CoreMatchers.containsString(
                "Property 'BacklinksSource.childNotExist' declared as origin of linking objects property 'BacklinksTarget.parents' does not exist"
        ));
    }
}

@Test(expected = RandomitoException.class)
public void testCreateForType_exception() {
    // given
    Class<ClassWithNoDefConstructor> type = ClassWithNoDefConstructor.class;

    // when
    Object forType = service.createForType(this, type);

    // then
    Assert.assertThat(forType, CoreMatchers.is(CoreMatchers.notNullValue()));
    Assert.assertTrue(forType.getClass() == type);
}

@Test
public void shouldIgnoreNullKeysWhenRestoring() throws Exception {
    assignPartition(3, topicPartition);
    final byte[] bytes = new byte[0];
    consumer.addRecord(new ConsumerRecord<>(topicPartition.topic(), topicPartition.partition(), 0, bytes, bytes));
    consumer.addRecord(new ConsumerRecord<>(topicPartition.topic(), topicPartition.partition(), 1, (byte[]) null, bytes));
    consumer.addRecord(new ConsumerRecord<>(topicPartition.topic(), topicPartition.partition(), 2, bytes, bytes));
    consumer.assign(Collections.singletonList(topicPartition));
    changelogReader.register(new StateRestorer(topicPartition, callback, null, Long.MAX_VALUE, false));
    changelogReader.restore();

    assertThat(callback.restored, CoreMatchers.equalTo(Utils.mkList(KeyValue.pair(bytes, bytes), KeyValue.pair(bytes, bytes))));
}

@Test
public void testConcatMatrix() throws Exception {
    int[][] matrixA = new int[][]{
        {1,0,1},{0,1,0},{1,0,0}
    };
    int[][] matrixB = new int[][]{
        {1,1,0,0},{0,1,0,0},{1,1,1,1}
    };

    int[][]result = WordClock.concatMatrix(matrixA,matrixB);
    assertThat("Should have concatenated correctly",result.length,CoreMatchers.equalTo(3));
    assertThat("Should have concatenated correctly",result[0].length,CoreMatchers.equalTo(4));

    assertThat("Should have concatenated correctly",result[0][0],CoreMatchers.equalTo(1));
    assertThat("Should have concatenated correctly",result[0][1],CoreMatchers.equalTo(1));
    assertThat("Should have concatenated correctly",result[0][2],CoreMatchers.equalTo(1));
    assertThat("Should have concatenated correctly",result[0][3],CoreMatchers.equalTo(0));

    assertThat("Should have concatenated correctly",result[1][0],CoreMatchers.equalTo(0));
    assertThat("Should have concatenated correctly",result[1][1],CoreMatchers.equalTo(1));
    assertThat("Should have concatenated correctly",result[1][2],CoreMatchers.equalTo(0));
    assertThat("Should have concatenated correctly",result[1][3],CoreMatchers.equalTo(0));

    assertThat("Should have concatenated correctly",result[2][0],CoreMatchers.equalTo(1));
    assertThat("Should have concatenated correctly",result[2][1],CoreMatchers.equalTo(1));
    assertThat("Should have concatenated correctly",result[2][2],CoreMatchers.equalTo(1));
    assertThat("Should have concatenated correctly",result[2][3],CoreMatchers.equalTo(1));
}

@Test
public void testAdditionToken() {
    final String expression = "4 + 2";
    final List<Token> tokens = tokenizer.tokenize( expression );
    final List<Token> expectedTokens = ImmutableList.of(
            Token.createLiteral( 4 ),
            Token.createOperation( Operation.PLUS ),
            Token.createLiteral( 2 ) );
    Assert.assertThat( tokens, CoreMatchers.equalTo( expectedTokens ) );
}