public Set apply(Set delegate) {
                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    Set<String> set1 = ImmutableSet.of("one");
    Set<String> set2 = ImmutableSet.of("two");
    new EqualsTester()
        .addEqualityGroup(set1, wrap(set1), wrap(set1))
        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    Multiset<String> set1 = ImmutableMultiset.of("one");
    Multiset<String> set2 = ImmutableMultiset.of("two");
    new EqualsTester()
        .addEqualityGroup(set1, wrap(set1), wrap(set1))
        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

        if (value == null) {
            return true;
        }

        final HibernateConstraintValidatorContext hibernateContext = context.unwrap(HibernateConstraintValidatorContext.class);
        hibernateContext.disableDefaultConstraintViolation();

		APICode: "kms:NotSupported",
		Err:     "requested functionality is not supported",
	}
)

// Error is a KMS error that can be translated into an S3 API error.
//
// It does not implement the standard error Unwrap interface for
// better error log messages.
type Error struct {
	Code    int    // The HTTP status code returned to the client
	APICode string // The API error code identifying the error

            }
        }
    }


    /**
     * 
     * {@inheritDoc}
     *
     * @see jcifs.SID#unwrap(java.lang.Class)
     */
    @SuppressWarnings ( "unchecked" )
    @Override
    public <T> T unwrap ( Class<T> t ) {
        if ( t.isAssignableFrom(this.getClass()) ) {
            return (T) this;
        }
        throw new ClassCastException();
    }

    assertEquals(
        hashFunction.hashBytes(ByteBuffer.wrap(bytes)),
        hashFunction.newHasher(size).putBytes(ByteBuffer.wrap(bytes)).hash());
    int off = random.nextInt(size);
    int len = random.nextInt(size - off);
    assertEquals(
        hashFunction.hashBytes(ByteBuffer.wrap(bytes, off, len)),
        hashFunction.newHasher(size).putBytes(ByteBuffer.wrap(bytes, off, len)).hash());
  }

                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    NavigableSet<String> set1 = ImmutableSortedSet.of("one");
    NavigableSet<String> set2 = ImmutableSortedSet.of("two");
    new EqualsTester()
        .addEqualityGroup(set1, wrap(set1), wrap(set1))
        .addEqualityGroup(set2, wrap(set2))
        .testEquals();
  }

            searchEngineClient.admin().indices().prepareClose(docIndex).execute(ActionListener.wrap(res -> {
                logger.info("Close {}", docIndex);
                searchEngineClient.admin().indices().prepareOpen(docIndex).execute(
                        ActionListener.wrap(res2 -> logger.info("Open {}", docIndex), e -> logger.warn("Failed to open {}", docIndex, e)));

    assertTrue(okSource.wasStreamClosed());
  }

  public void testConcat() throws IOException {
    ByteSource b1 = ByteSource.wrap(new byte[] {0, 1, 2, 3});
    ByteSource b2 = ByteSource.wrap(new byte[0]);
    ByteSource b3 = ByteSource.wrap(new byte[] {4, 5});

    byte[] expected = {0, 1, 2, 3, 4, 5};

    assertArrayEquals(expected, ByteSource.concat(ImmutableList.of(b1, b2, b3)).read());

  }

  public void testRowKeySet() {
    assertEquals(ImmutableSet.of(), INSTANCE.rowKeySet());
  }

  public void testRowMap() {
    assertEquals(ImmutableMap.of(), INSTANCE.rowMap());
  }

  public void testValues() {
    assertTrue(INSTANCE.values().isEmpty());
  }