if (buffer == null || buffer.length < bufferIndex + 4) {
                    throw new SMBProtocolDecodingException("Buffer too small");
                }
                return 4;
            }

            @Override
            public int encode(byte[] dst, int dstIndex) {
                return 4;
            }

        .Builder()
        .body("def")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    val call2 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response2 = call2.execute()
    assertThat(response2.body.string()).isEqualTo("def")
    response2.close()
  }

  @Test

            return entity;
        });
    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verify the CRUD mode.
     * @param crudMode The CRUD mode.
     * @param expectedMode The expected mode.

      sort(
          insertionOrder,
          new Comparator<V>() {
            @Override
            public int compare(V left, V right) {
              // The indexes are small enough for the subtraction trick to be safe.
              return indexOfEntryWithValue(left) - indexOfEntryWithValue(right);
            }

            int indexOfEntryWithValue(V value) {

threshold for this to be true is not precisely defined by law.

  If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the

   *     new ImmutableBiMap.Builder<String, Integer>()
   *         .put("one", 1)
   *         .put("two", 2)
   *         .put("three", 3)
   *         .buildOrThrow();
   * }
   *
   * <p>For <i>small</i> immutable bimaps, the {@code ImmutableBiMap.of()} methods are even more
   * convenient.
   *
   * <p>By default, a {@code Builder} will generate bimaps that iterate over entries in the order

            return entity;
        });
    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verify the CRUD mode.
     * @param crudMode The CRUD mode.
     * @param expectedMode The expected mode.

    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verifies that the CRUD mode matches the expected mode.
     *
     * @param crudMode the actual CRUD mode

				case reflect.Slice:
					queryFields = db.Statement.ReflectValue.Type().Elem() != db.Statement.Schema.ModelType
				}
			}

			if queryFields {
				stmt := gorm.Statement{DB: db}
				// smaller struct
				if err := stmt.Parse(db.Statement.Dest); err == nil && (db.QueryFields || stmt.Schema.ModelType != db.Statement.Schema.ModelType) {
					clauseSelect.Columns = make([]clause.Column, len(stmt.Schema.DBNames))

        ValidateNegotiateInfoRequest request =
                new ValidateNegotiateInfoRequest(DEFAULT_CAPABILITIES, defaultClientGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        // Create buffer smaller than required size
        byte[] smallBuffer = new byte[request.size() - 1];

        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            request.encode(smallBuffer, 0);
        });
    }