assertThat(callCount.get()).isEqualTo(2);
  }

  /**
   * On a concurrent computation that throws an unchecked exception, all threads should get the
   * (wrapped) exception, with the loader called only once. The result should not be cached (a later
   * request should call the loader again).
   */

   * known as the XON code used for software flow control in serial communications. The main use is
   * restarting the transmission after the communication has been stopped by the XOFF control code.
   *
   * @since 8.0
   */
  public static final byte XON = 17; // aka DC1

  /**
   * Device Control 2. Characters for the control of ancillary devices associated with data

found in the _cgo_export.h generated header, after any preambles
copied from the cgo input files. Functions with multiple
return values are mapped to functions returning a struct.

Not all Go types can be mapped to C types in a useful way.
Go struct types are not supported; use a C struct type.
Go array types are not supported; use a C pointer.

            }
            return id;
        }
    }

    /**
     * Statistics data object that stores timestamped events and maintains reference counting.
     * Extends LinkedHashMap to store event names mapped to their timestamps.
     * Includes reference counting for multi-threaded access tracking.
     */
    public static class StatsObject extends LinkedHashMap<String, Long> {

        trans2QueryFSInfo = new Trans2QueryFSInformation(config, infoLevel);

        byte[] buffer = new byte[512];
        trans2QueryFSInfo.writeParametersWireFormat(buffer, 0);

        // Check mapped information level
        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);
        assertEquals(expectedMappedValue, actualInfoLevel);
    }

    @Test

        trans2SetFileInfo = new Trans2SetFileInformation(config, TEST_FID, mockFileInfo);

        byte[] buffer = new byte[512];
        trans2SetFileInfo.writeParametersWireFormat(buffer, 0);

        // Check mapped information level
        int actualInfoLevel = SMBUtil.readInt2(buffer, 2);
        assertEquals(expectedMappedValue, actualInfoLevel);
    }

    @Test
    @DisplayName("Test with null buffer in read methods")

//	    return func (db *gorm.DB) *gorm.DB {
//	        return db.Scopes(AmountGreaterThan1000).Where("status in (?)", status)
//	    }
//	}
//
//	db.Scopes(AmountGreaterThan1000, OrderStatus([]string{"paid", "shipped"})).Find(&orders)
func (db *DB) Scopes(funcs ...func(*DB) *DB) (tx *DB) {
	tx = db.getInstance()
	tx.Statement.scopes = append(tx.Statement.scopes, funcs...)
	return tx
}

 *       collection. This is a stronger guarantee than that of {@link
 *       Collections#unmodifiableCollection}, whose contents change whenever the wrapped collection
 *       is modified.
 *   <li><b>Null-hostility.</b> This collection will never contain a null element.
 *   <li><b>Deterministic iteration.</b> The iteration order is always well-defined, depending on

          .put(GenericDeclaration.class, Object.class)
          .put(Type.class, Object.class)
          .build();

  /**
   * type → implementation. Inherently mutable interfaces and abstract classes are mapped to their
   * default implementations and are "new"d upon get().
   */
  private static final ConcurrentMap<Class<?>, Class<?>> implementations = Maps.newConcurrentMap();

  Collection<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values);

  /**
   * Removes all values associated with the key {@code key}.
   *
   * <p>Once this method returns, {@code key} will not be mapped to any values, so it will not
   * appear in {@link #keySet()}, {@link #asMap()}, or any other views.
   *
   * @return the values that were removed (possibly empty). The returned collection <i>may</i> be