}

    def method(String name, ClassMetaData classMetaData) {
        return method([:], name, classMetaData)
    }

    def method(Map<String, ?> args, String name, ClassMetaData classMetaData) {
        MethodMetaData method = Mock()
        List<String> paramTypes = args.paramTypes ?: []
        _ * method.name >> name
        _ * method.overrideSignature >> "$name(${paramTypes.join(', ')})"

pkg sync/atomic, method (*Int32) And(int32) int32 #61395
pkg sync/atomic, method (*Int32) Or(int32) int32 #61395
pkg sync/atomic, method (*Int64) And(int64) int64 #61395
pkg sync/atomic, method (*Int64) Or(int64) int64 #61395
pkg sync/atomic, method (*Uint32) And(uint32) uint32 #61395
pkg sync/atomic, method (*Uint32) Or(uint32) uint32 #61395
pkg sync/atomic, method (*Uint64) And(uint64) uint64 #61395

ECL0044=Class not found, details are {0}
ECL0048=The constructor of {0} for arguments({1}) not found
ECL0049=The method({1}) of {0} not found
ECL0050=Can not parse, because {0}
ECL0051=Can not parse of ({0})
ECL0053=Bad parser configuration, because {0}
ECL0054=SAXException occurred, because {0}
ECL0055=Resource({0}) not found
ECL0057=Method({1}) of class({0}) not found
ECL0059=Can not configure property({1}) of {0}, because {2}

    factory.tearDown();
  }

  static ImmutableList<Method> getTestMethods(Class<?> testClass) {
    List<Method> result = new ArrayList<>();
    for (Method method : testClass.getDeclaredMethods()) {
      if (Modifier.isPublic(method.getModifiers())
          && method.getReturnType() == void.class
          && method.getParameterTypes().length == 0
          && method.getName().startsWith("test")) {
        result.add(method);

   * {@link Collections#frequency} (which would presumably perform more poorly).
   *
   * <p><b>Note:</b> the utility method {@link Iterables#frequency} generalizes this operation; it
   * correctly delegates to this method when dealing with a multiset, but it can also accept any
   * other iterable type.
   *
   * @param element the element to count occurrences of

    void testGetConfig() {
        // Test getConfig() method
        Configuration mockConfig = mock(Configuration.class);
        when(mockDelegate.getConfig()).thenReturn(mockConfig);
        assertEquals(mockConfig, cifsContextWrapper.getConfig());
        verify(mockDelegate).getConfig();
    }

    @Test
    void testGetDfs() {
        // Test getDfs() method
        DfsResolver mockDfsResolver = mock(DfsResolver.class);

                added("Method", "SourceKt.foo()"),
                added("Method", "SourceKt.fooExt(int)"),
                added("Method", "SourceKt.fooExt(java.lang.String)"),
                added("Method", "SourceKt.getBar()"),
                added("Method", "SourceKt.getBarExt(java.lang.String)"),
                added("Method", "SourceKt.getBazar()"),
                added("Method", "SourceKt.getBazarExt(int)"),

   *   <li>If the constructor or factory method used to construct instance takes a parameter that
   *       {@link AbstractPackageSanityTests} doesn't know how to construct, the test will fail.
   *   <li>If there is no visible constructor or visible static factory method declared by {@code
   *       C}, instance methods are skipped for nulls test.

 * provided {@code standardAddAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingNavigableSet}.
 *
 * <p>Each of the {@code standard} methods uses the set's comparator (or the natural ordering of the

 * provided {@code standardPutAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingMap}.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use {@link Objects#equals} to test