Example #1
0
  @Test
  public void shouldNotBeEqualToNullOrOtherObjects() throws Exception {
    Token expected = new Token("access", "secret");

    assertNotSame(expected, null);
    assertNotSame(expected, new Object());
  }
  @Test
  public void testUnCachedPrepared() throws Exception {
    BitronixTransactionManager tm = TransactionManagerServices.getTransactionManager();
    tm.setTransactionTimeout(60);
    tm.begin();

    Connection connection = poolingDataSource2.getConnection();

    PreparedStatement prepareStatement1 =
        connection.prepareStatement("SELECT 1 FROM nothing WHERE a=? AND b=? AND c=? AND d=?");
    PreparedStatement prepareStatement2 =
        connection.prepareStatement("SELECT 1 FROM nothing WHERE a=? AND b=? AND c=? AND d=?");

    Assert.assertNotSame(prepareStatement1, prepareStatement2);

    prepareStatement2.close();

    prepareStatement2 =
        connection.prepareStatement("SELECT 1 FROM nothing WHERE a=? AND b=? AND c=? AND d=?");
    Assert.assertNotSame(prepareStatement1, prepareStatement2);

    prepareStatement1.close();
    prepareStatement2.close();

    connection.close();
    tm.shutdown();
  }
 @Test
 public void canAnswerLastGestureDetector() throws Exception {
   GestureDetector newDetector = new GestureDetector(Robolectric.application, null);
   assertNotSame(newDetector, ShadowGestureDetector.getLastActiveDetector());
   newDetector.onTouchEvent(null);
   assertSame(newDetector, ShadowGestureDetector.getLastActiveDetector());
 }
Example #4
0
  /** Test we can create an Buffer, then modify the direct bytes in native code. */
  @Test
  public void testCanDirectlyModifyNativeBytes() {
    byte buffer[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    Buffer buf = Buffer.make(null, buffer, 0, buffer.length);
    assertNotNull(buf);
    assertEquals(buf.getBufferSize(), buffer.length);

    // this give us the native bytes
    java.nio.ByteBuffer nativeBytes = buf.getByteBuffer(0, buffer.length);
    assertNotNull(nativeBytes);
    for (int i = 0; i < buffer.length; i++) {
      nativeBytes.put(i, (byte) (9 - buffer[i])); // reverse the order of the integers
    }
    // we can release it.  no "update" method should be required.  It should
    // have modified the underlying C++ bytes.
    nativeBytes = null;

    // now, get a copy of the bytes in the Buffer and make sure
    // the order of bytes was reversed.
    byte outBuffer[] = buf.getByteArray(0, buffer.length);
    assertNotNull(outBuffer);
    assertEquals(outBuffer.length, buffer.length);
    assertNotSame(buf, outBuffer);
    for (int i = 0; i < buffer.length; i++) {
      assertEquals(9 - buffer[i], outBuffer[i]);
    }
  }
Example #5
0
 public void testAll() throws Exception {
   // Hash测试
   Assert.assertEquals(
       "3ffda29e8fbc3756ded50aa496cf3019", UEncrypt.getHash(UEncrypt.HASH_TYPE_MD5, "ctyun"));
   Assert.assertEquals(
       "efd4ea5525e0116c1bc3267ec3b9cca0d6416a02",
       UEncrypt.getHash(UEncrypt.HASH_TYPE_SHA1, "ctyun"));
   Assert.assertEquals(
       "4b1d518cb87ec169ed3c29a9b2856266c9e72964f318ab3de376f98dc6f89df7",
       UEncrypt.getHash(UEncrypt.HASH_TYPE_SHA256, "ctyun"));
   // CheckCode测试
   Assert.assertEquals(
       Long.valueOf(1603231608),
       UEncrypt.getCheckCodeNum(UEncrypt.CHECK_CODE_TYPE_CRC32, "ctyun"));
   Assert.assertEquals(
       "5f8f5f78", UEncrypt.getCheckCodeStr(UEncrypt.CHECK_CODE_TYPE_CRC32, "ctyun"));
   Assert.assertEquals(
       Long.valueOf(109511220),
       UEncrypt.getCheckCodeNum(UEncrypt.CHECK_CODE_TYPE_ADLER32, "ctyun"));
   Assert.assertEquals(
       "6870234", UEncrypt.getCheckCodeStr(UEncrypt.CHECK_CODE_TYPE_ADLER32, "ctyun"));
   // System.out.println(UEncrypt.getCheckCode(UEncrypt.CHECK_CODE_TYPE_CRC32, new
   // FileInputStream(new File("C:\\kvlogs\\info-127.0.0.1.log"))));
   // System.out.println(UEncrypt.getCheckCode(UEncrypt.CHECK_CODE_TYPE_ADLER32, new
   // FileInputStream(new File("C:\\kvlogs\\info-127.0.0.1.log"))));
   // rot13测试
   Assert.assertEquals("abcDEFghi123", UEncrypt.rot13(UEncrypt.rot13("abcDEFghi123")));
   // 随机数测试
   Assert.assertNotSame(UEncrypt.getRandomInteger(4), UEncrypt.getRandomInteger(4));
   Assert.assertEquals(4, UEncrypt.getRandomInteger(4).length());
 }
Example #6
0
  /**
   * Allows the Interceptor to do some processing on the request before and/or after the rest of the
   * processing of the request by the DefaultActionInvocation or to short-circuit the processing and
   * just return a String return code.
   *
   * @param invocation
   * @return
   * @throws Exception
   */
  public String intercept(ActionInvocation invocation) throws Exception {
    executed = true;
    Assert.assertNotSame(DEFAULT_FOO_VALUE, foo);
    Assert.assertEquals(expectedFoo, foo);

    return invocation.invoke();
  }
  @Test
  public void shouldReturnNullLocationWhenACriteriaFailsAndNoBestExists() {
    addCriteria(failsCriteria);

    Location location = bestLocationDelegate.getBestLastKnownLocation();
    assertNull(location);
    assertNotSame(location, candidateLocation);
  }
 @Test
 public void readImgCLogFileNameTest() {
   // when
   final String r = SystemPropertiesReader.readImgCLogFileName();
   // then
   assertNotNull(r);
   assertNotSame(r, "");
 }
 @Test
 public void readImgCIgnorePathArgsKeyTest() {
   // when
   final String r = SystemPropertiesReader.readImgCIgnorePathArgsKey();
   // then
   assertNotNull(r);
   assertNotSame(r, "");
 }
 @Test
 public void readImgCConfigurationFileArgsKeyTest() {
   // when
   final String r = SystemPropertiesReader.readImgCConfigurationFileArgsKey();
   // then
   assertNotNull(r);
   assertNotSame(r, "");
 }
 @Test
 public void readImgCCacheFileDefaultTest() {
   // when
   final String r = SystemPropertiesReader.readImgCCacheFileDefault();
   // then
   assertNotNull(r);
   assertNotSame(r, "");
 }
  @Test
  public void graphType() {
    Shell shell = new Shell();
    Graph graph = interpreter.create(shell, SWT.NONE, "graph Sample{1;2;1--2}");
    Assert.assertNotNull("Created graph must not be null", graph);
    Assert.assertNotSame(ZestStyles.CONNECTIONS_DIRECTED, graph.getConnectionStyle());
    // open(shell);

  }
Example #13
0
  @Test
  public void testMouseOver() {
    driver.get(fixture("mouse.html"));

    OperaWebElement test = ((OperaWebElement) driver.findElementById("test"));
    String hash = test.getImageHash();
    test.mouseOver();
    Assert.assertNotSame(hash, test.getImageHash());
  }
Example #14
0
  @Test
  public void testAllRowsReaderWithCancel() throws Exception {
    final AtomicLong counter = new AtomicLong(0);

    AllRowsReader<String, String> reader =
        new AllRowsReader.Builder<String, String>(keyspace, CF_STANDARD1)
            .withPageSize(3)
            .withConcurrencyLevel(2)
            .forEachRow(
                new Function<Row<String, String>, Boolean>() {
                  @Override
                  public Boolean apply(Row<String, String> row) {
                    try {
                      Thread.sleep(2000);
                    } catch (InterruptedException e) {
                      Thread.currentThread().interrupt();
                      throw new RuntimeException(e);
                    }
                    counter.incrementAndGet();
                    LOG.info("Got a row: " + row.getKey().toString());
                    return true;
                  }
                })
            .build();

    Future<Boolean> future = Executors.newSingleThreadExecutor().submit(reader);

    Thread.sleep(1000);

    reader.cancel();

    try {
      boolean result = future.get();
      Assert.assertEquals(false, result);
    } catch (Exception e) {
      LOG.info("Failed to execute", e);
    }
    LOG.info("Before: " + counter.get());
    Assert.assertNotSame(28, counter.get());
    Thread.sleep(2000);
    LOG.info("After: " + counter.get());
    Assert.assertNotSame(28, counter.get());
  }
Example #15
0
  @Test
  public void getPropertiesFromFile() throws Exception {
    System.out.println("checking known properties");

    assertEquals(runProcess("hostname"), BuildData.host);
    assertEquals(runProcess("whoami"), BuildData.user);
    assertEquals(runProcess("pwd"), BuildData.repo);

    System.out.println("checking other properties");

    assertNotNull(BuildData.repo_status);
    assertNotSame(BuildData.RepoStatus.UNKNOWN, BuildData.repo_status);

    assertNotNull(BuildData.short_revision);
    assertNotSame("000001", BuildData.short_revision);

    assertNotNull(BuildData.timestamp);
    assertNotSame("000000001", BuildData.timestamp);
  }
 @Test
 public void compareObjectsWithSameNameInDifferentContainers() {
   Container container1 = account.getContainer("alpha");
   StoredObject object1 = container1.getObject("img1.png");
   Container container2 = account.getContainer("beta");
   StoredObject object2 = container2.getObject("img1.png");
   assertNotSame(object1, object2);
   assertEquals(-1, object1.compareTo(object2));
   assertEquals(1, object2.compareTo(object1));
 }
Example #17
0
  private void testEncryptDecrypt(final CryptoUtil cryptoUtil, final String textToEncrypt)
      throws Exception {
    String encryptedText = cryptoUtil.encrypt(textToEncrypt);
    assertNotSame(
        "Encrypted text should not be the same as the plain text", textToEncrypt, encryptedText);

    String decryptedText = cryptoUtil.decrypt(encryptedText);
    assertEquals(
        "Decrypted text should be the same as the original text", textToEncrypt, decryptedText);
  }
  @Test
  public void proxyPassesCallOnToDecoratedObject() {
    Tester rateLimitedTester =
        rateLimiterFactory.limitRate(
            mockTester, methodMatching(".*"), fixedCost(1), new RateLimit(10, 10, perSecond(0)));
    rateLimitedTester.rateLimitMe(11);

    verify(mockTester).rateLimitMe(11);
    assertNotSame(rateLimitedTester, mockTester);
  }
 @Test
 public void testRegistryFactoryGroupCache() throws Exception {
   Registry registry1 =
       registryFactory.getRegistry(
           URL.valueOf("dubbo://" + NetUtils.getLocalHost() + ":2233?group=aaa"));
   Registry registry2 =
       registryFactory.getRegistry(
           URL.valueOf("dubbo://" + NetUtils.getLocalHost() + ":2233?group=bbb"));
   Assert.assertNotSame(registry1, registry2);
 }
Example #20
0
 /**
  * Asserts that an expected {@link Activity} is currently active one, with the possibility to
  * verify that the expected {@code Activity} is a new instance of the {@code Activity}.
  *
  * @param message the message that should be displayed if the assert fails
  * @param expectedClass the {@code Class} object that is expected to be active e.g. {@code
  *     MyActivity.class}
  * @param isNewInstance {@code true} if the expected {@code Activity} is a new instance of the
  *     {@code Activity}
  */
 public void assertCurrentActivity(
     String message, Class<? extends Activity> expectedClass, boolean isNewInstance) {
   boolean found = false;
   assertCurrentActivity(message, expectedClass);
   Activity activity = activityUtils.getCurrentActivity();
   for (int i = 0; i < activityUtils.getAllOpenedActivities().size() - 1; i++) {
     String instanceString = activityUtils.getAllOpenedActivities().get(i).toString();
     if (instanceString.equals(activity.toString())) found = true;
   }
   Assert.assertNotSame(message + ", isNewInstance: actual and ", isNewInstance, found);
 }
  @Test
  public void testWhenPageSizeChanged() {
    int newPageSize = PipelinedLeaderboard.DEFAULT_PAGE_SIZE / 2;
    assertNotSame(newPageSize, PipelinedLeaderboard.DEFAULT_PAGE_SIZE);

    underTest.setPageSize(newPageSize);
    List<Entry> found = underTest.aroundMe(leaderboardName, MID_RANKED_USER);
    Assert.assertNotNull("Should have returned a list of users", found);
    assertEquals("Should have the modified page size of users", newPageSize, found.size());
    testEntriesAreOrdered(found);
    testEntriesAreCorrect(found, underTest.isUseZeroIndexForRank());
  }
  @Test
  public void testEquals() throws Exception {
    assertEquals("Should be equal to itself", METADATA_1, METADATA_1);

    EditLogLedgerMetadata allFieldsMatch =
        new EditLogLedgerMetadata(
            METADATA_1.getLogVersion(), METADATA_1.getLedgerId(),
            METADATA_1.getFirstTxId(), METADATA_1.getLastTxId());
    assertEquals("Should be equal if all fields match", METADATA_1, allFieldsMatch);

    assertNotSame("Should not be equal if fields do not match", METADATA_1, METADATA_2);
  }
  @Test
  public void testUnique() {
    class Test {
      @AutoWire(name = "test", unique = true)
      DoubleNode mWriter;
    }

    Test t1 = new Test();
    Test t2 = new Test();
    DatastreamManager.autowire(t1);
    DatastreamManager.autowire(t2);
    Assert.assertNotSame(t1.mWriter, t2.mWriter);
  }
  @Test
  public void testConstructor_fromDsObject() throws Exception {
    AccountProperty accountProperty = new AccountProperty();
    AdapterProperty property = AdapterProperty.getAdapter(accountProperty);
    Assert.assertEquals(accountProperty, property.getAssociatedObject());

    AccountProperty accountProperty2 = new AccountProperty();
    AdapterProperty property2 = AdapterProperty.getAdapter(accountProperty2);
    Assert.assertNotSame(property, property2);

    AdapterProperty property3 = AdapterProperty.getAdapter(accountProperty);
    Assert.assertEquals(property, property3);
  }
  @Test
  public void testGetDifferentSession() throws UnknownHostException {

    MessagePack messagePack = new MessagePack();
    EventLoop loop = EventLoop.start(messagePack);

    SessionPool sp = new SessionPool(loop);

    Session s1 = sp.getSession("localhost", 8840);
    Session s2 = sp.getSession("localhost", 8841);

    Assert.assertNotSame(s1, s2);
  }
Example #26
0
  @Test
  public void testSingleBond() {
    IAtomContainer container = makeSingleBond();

    // generate the single line element
    IRenderingElement root = generator.generate(container, model);
    List<IRenderingElement> elements = elementUtil.getAllSimpleElements(root);
    Assert.assertEquals(1, elements.size());

    // test that the endpoints are distinct
    LineElement line = (LineElement) elements.get(0);
    Assert.assertNotSame(0, AbstractGeneratorTest.length(line));
  }
Example #27
0
 /**
  * Test that we can create a Buffer from a Java byte[] array, and that we can copy the same data
  * out of an Buffer (via copy).
  */
 @Test
 public void testCreateFromBytes() {
   byte buffer[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   Buffer buf = Buffer.make(null, buffer, 0, buffer.length);
   assertNotNull(buf);
   assertEquals(buf.getBufferSize(), buffer.length);
   byte outBuffer[] = buf.getByteArray(0, buffer.length);
   assertNotNull(outBuffer);
   assertEquals(outBuffer.length, buffer.length);
   assertNotSame(buf, outBuffer);
   for (int i = 0; i < buffer.length; i++) {
     assertEquals(buffer[i], outBuffer[i]);
   }
 }
Example #28
0
  @Test
  public void testNegative() throws InvalidFormatException {
    OutputStream stream = new ByteArrayOutputStream();
    TokenizerEvaluationMonitor listener = new TokenEvaluationErrorListener(stream);

    TokenizerEvaluator eval =
        new TokenizerEvaluator(new DummyTokenizer(TokenSampleTest.createGoldSample()), listener);

    eval.evaluateSample(TokenSampleTest.createPredSample());

    assertEquals(.5d, eval.getFMeasure().getFMeasure(), .1d);

    assertNotSame(0, stream.toString().length());
  }
  @Test
  public void testUsersGetInfo() throws Exception {
    FacebookJaxbRestClient client =
        FacebookSessionTestUtils.getValidClient(FacebookJaxbRestClient.class);

    long logged = client.users_getLoggedInUser();
    List<Long> users = Collections.singletonList(logged);
    EnumSet<ProfileField> fields = EnumSet.allOf(ProfileField.class);
    UsersGetInfoResponse response = client.users_getInfo(users, fields);

    String name = response.getUser().get(0).getName();

    Assert.assertNotNull(name);
    Assert.assertNotSame("", name);
  }
  @Test
  public void chargingStationConfiguredEvent() {
    eventHandler.handle(
        new ChargingStationCreatedEvent(
            CHARGING_STATION_ID, USER_IDENTITIES_WITH_ALL_PERMISSIONS, NULL_USER_IDENTITY_CONTEXT));
    ChargingStation cs = chargingStationRepository.findOne(CHARGING_STATION_ID.getId());
    assertFalse(cs.isConfigured());
    assertNotSame(cs.getNumberOfEvses(), EVSES.size());

    eventHandler.handle(
        new ChargingStationConfiguredEvent(CHARGING_STATION_ID, EVSES, NULL_USER_IDENTITY_CONTEXT));

    cs = chargingStationRepository.findOne(CHARGING_STATION_ID.getId());
    assertTrue(cs.isConfigured());
    assertEquals(cs.getNumberOfEvses(), EVSES.size());
  }