assertTrue(multimap.keySet() instanceof SortedSet);
    assertTrue(multimap.asMap() instanceof SortedMap);
  }

  // J2kt cannot translate the Comparable rawtype in a usable way (it becomes Comparable<Object>
  // but types are typically only Comparable to themselves).
  @SuppressWarnings({"rawtypes", "unchecked"})
  private static MultimapBuilderWithKeys<Comparable<?>> rawtypeToWildcard(

		return
	}

	if cap(b) != bp.wcap {
		// someone tried to put back buffer which is not part of this buffer pool
		// we simply don't put this back into pool, a modified buffer provided
		// by this package is no more usable, callers make sure to not modify
		// the capacity of the buffer.
		return
	}

	select {
	case bp.c <- b[:bp.w]:
		// buffer went back into pool
	default:
		// buffer didn't go back into pool, just discard

                    }
                }
            }
        }

        return plugins.keySet();
    }

    /**
     * Performs a lookup using Plexus API to make sure we can look up only "visible" (see Maven classloading) components
     * from current module and for example not extensions coming from other modules.
     */
    private LifecycleMapping lookupLifecycleMapping(final String packaging) {

		}); err == nil {
			t.Fatalf("nested transaction should returns error")
		}

		if err := tx.First(&User{}, "name = ?", user1.Name).Error; err != nil {
			t.Fatalf("Should not rollback record if disabled nested transaction support")
		}

		if err := tx.Transaction(func(tx2 *gorm.DB) error {
			tx2.Create(&user2)

			if err := tx2.First(&User{}, "name = ?", user2.Name).Error; err != nil {

   * algorithms should document their behavior in the presence of duplicates.
   *
   * <p>The elements of the returned {@code Iterable} must each be:
   *
   * <ul>
   *   <li>Non-null
   *   <li>Usable as {@code Map} keys (see the Guava User Guide's section on <a
   *       href="https://github.com/google/guava/wiki/GraphsExplained#graph-elements-nodes-and-edges">
   *       graph elements</a> for details)
   * </ul>
   *

   * algorithms should document their behavior in the presence of duplicates.
   *
   * <p>The elements of the returned {@code Iterable} must each be:
   *
   * <ul>
   *   <li>Non-null
   *   <li>Usable as {@code Map} keys (see the Guava User Guide's section on <a
   *       href="https://github.com/google/guava/wiki/GraphsExplained#graph-elements-nodes-and-edges">
   *       graph elements</a> for details)
   * </ul>
   *

      }
    }

    // Write the payload.
    sink.writeAll(content)
  }

  /**
   * Execute [block] with a new namespace for type hints. Type hints from the enclosing type are no
   * longer usable by the current type's members.
   */
  fun <T> withTypeHint(block: () -> T): T {
    typeHintStack.add(null)
    try {
      return block()
    } finally {
      typeHintStack.removeAt(typeHintStack.size - 1)

# Contributor Covenant Code of Conduct

## Our Pledge

We as members, contributors, and leaders pledge to participate in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, religion, or sexual identity
and orientation.

This is particularly so if the compression ratio of your content reveals information about it.
See [CRIME TLS](https://en.wikipedia.org/wiki/CRIME) as an example of this.

Therefore, compression is disabled when encrypting by default, and must be enabled separately.

Consult our security experts on [SUBNET](https://min.io/pricing) to help you evaluate if
your setup can use this feature combination safely.

        assertEquals(obj.name, result.name);
        assertEquals(obj.value, result.value);
    }

    /**
     * Test null filter disables filtering
     *
     * @throws Exception
     */
    public void testFromBinaryToObject_NullFilter() throws Exception {
        final String str = "test";