final Crawler crawler1 = getComponent(Crawler.class);
            crawler1.setBackground(true);
            ((UrlFilterImpl) crawler1.urlFilter).setIncludeFilteringPattern("$1$2$3.*");
            crawler1.addUrl(url1);
            crawler1.getCrawlerContext().setMaxAccessCount(maxCount);
            crawler1.getCrawlerContext().setNumOfThread(numOfThread);

            // When: Creating connect2 message
            samr.SamrConnect2 message = new samr.SamrConnect2("system", 123, mockPolicyHandle);

            // Then: Should have correct values
            assertEquals(0x39, message.getOpnum());
            assertEquals("system", message.system_name);
            assertEquals(123, message.access_mask);
            assertEquals(mockPolicyHandle, message.handle);
        }

        @Test

    public void test_append_integerValue() {
        StringBuilder buf = new StringBuilder();
        Supplier<Object> supplier = () -> Integer.valueOf(123);

        monitorTarget.append(buf, "intKey", supplier);
        assertEquals("\"intKey\":123", buf.toString());
    }

    // Test append method with Long value
    public void test_append_longValue() {
        StringBuilder buf = new StringBuilder();

        ;
        includeFilter = container.getComponent("includeFilter");
        includeFilter.setIncludeFilteringPattern("$1$2$3.*");
        excludeFilter = container.getComponent("excludeFilter");
        excludeFilter.setExcludeFilteringPattern("$1$2$3.*");
        domainFilter = container.getComponent("domainFilter");
        domainFilter.setIncludeFilteringPattern("http://$2/.*");

    assertThrows(NullPointerException.class, () -> builder.put(null, 1));
    assertThrows(NullPointerException.class, () -> builder.putAll(null, Arrays.asList(1, 2, 3)));
    assertThrows(NullPointerException.class, () -> builder.putAll(null, 1, 2, 3));
    assertThrows(
        NullPointerException.class, () -> builder.putAll((Multimap<String, Integer>) toPut));
  }

  public void testBuilderPutNullValue() {

    testRotate(new double[] {1, 2}, 2, new double[] {1, 2});
    testRotate(new double[] {1, 2}, 3, new double[] {2, 1});

    testRotate(new double[] {1, 2, 3}, -5, new double[] {3, 1, 2});
    testRotate(new double[] {1, 2, 3}, -4, new double[] {2, 3, 1});
    testRotate(new double[] {1, 2, 3}, -3, new double[] {1, 2, 3});
    testRotate(new double[] {1, 2, 3}, -2, new double[] {3, 1, 2});

        ASN1Integer expected = new ASN1Integer(123);
        vector.add(expected);
        ASN1Integer result = ASN1Util.as(ASN1Integer.class, vector.elements());
        assertSame(expected, result);
    }

    @Test
    void testAs_Enumeration_Failure() {
        // Test failed casting from enumeration
        Vector<ASN1Integer> vector = new Vector<>();
        vector.add(new ASN1Integer(123));

application/futuresplash       spl              # Macromedia Flash
application/hep                hep              # Hummingbird Host Explorer Profiles
application/lotus-123          wks              # Lotus 123
application/mac-binhex40       hqx              # Macintosh binhexed archives
application/mspowerpoint       ppt              # Microsoft Powerpoint
application/msword             doc              # Microsoft Word

/**
 * @author higa
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
public @interface Hoge {

    /**
     *
     */
    String aaa() default "123";

    /**
     *
     */
    String bbb();

    /**
     *
     */
    String ccc() default "";

              }
            });

    List<Integer> actual = Lists.newArrayList(result);
    List<Integer> expected = asList(1, 2, 3);
    assertEquals(expected, actual);
  }

  public void testTransformRemove() {
    List<String> list = Lists.newArrayList("1", "2", "3");
    Iterator<String> input = list.iterator();
    Iterator<Integer> iterator =
        Iterators.transform(
            input,