boolean increment;
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(isPowerOfTwo(x));
      // fall through
      case FLOOR:
        increment = false;
        break;
      case CEILING:
        increment = !isPowerOfTwo(x);
        break;
      case DOWN:
        increment = exponent < 0 & !isPowerOfTwo(x);
        break;
      case UP:

		return err
	}

	// Delete the event from store.
	return target.store.Del(key)
}

// Close - closes underneath connections to MySQL database.
func (target *MySQLTarget) Close() error {
	close(target.quitCh)
	if target.updateStmt != nil {
		// FIXME: log returned error. ignore time being.
		_ = target.updateStmt.Close()
	}

	if target.deleteStmt != nil {
		// FIXME: log returned error. ignore time being.

            return ansiHash;
        }
        switch (LM_COMPATIBILITY) {
        case 0:
        case 1:
            return getPreNTLMResponse(password, challenge);
        case 2:
            return getNTLMResponse(password, challenge);
        case 3:
        case 4:
        case 5:
            if (clientChallenge == null) {
                clientChallenge = new byte[8];

 * protection against buffer overflow, integer overflow, and other attacks.
 */
public class Smb2NegotiateResponseInputValidationTest {

    private Configuration mockConfig;
    private Smb2NegotiateResponse response;

    @BeforeEach
    public void setUp() {
        mockConfig = Mockito.mock(Configuration.class);
        response = new Smb2NegotiateResponse(mockConfig);
    }

    /**

## Classe de resposta padrão { #default-response-class }

Quando você criar uma instância da classe **FastAPI** ou um `APIRouter` você pode especificar qual classe de resposta utilizar por padrão.

O parâmetro que define isso é o `default_response_class`.

/** Static utility method for unchecked throwing of any {@link Throwable}. */
@GwtCompatible
final class SneakyThrows<T extends Throwable> {
  /**
   * Throws {@code t} as if it were an unchecked {@link Throwable}.
   *
   * <p>This method is useful primarily when we make a reflective call to a method with no {@code
   * throws} clause: Java forces us to handle an arbitrary {@link Throwable} from that method,

 * @since 3.0.2
 */
public abstract class AbstractEventSpy implements EventSpy {

    @Override
    public void init(Context context) throws Exception {}

    @Override
    public void onEvent(Object event) throws Exception {}

    @Override
    public void close() throws Exception {}

import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class XslTransformer {
    public static void main(String[] args) throws TransformerException, IOException {
        if (args.length < 3 || args.length > 4) {

 *
 * Baseline test if we ned to validate OkHttp behaviour against other popular clients.
 */
class ApacheHttpClientTest {
  private val httpClient = HttpClients.createDefault()

  @StartStop
  private val server = MockWebServer()

  @AfterEach
  fun tearDown() {
    httpClient.close()
  }

  @Test
  fun get() {
    server.enqueue(
      MockResponse
        .Builder()

import jcifs.internal.util.SMBUtil;

/**
 * Test class for Smb2TreeDisconnectResponse functionality
 */
@DisplayName("Smb2TreeDisconnectResponse Tests")
class Smb2TreeDisconnectResponseTest extends BaseTest {

    private Configuration mockConfig;
    private Smb2TreeDisconnectResponse response;

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);