t.Fatalf("invalid sql generated, got %v", actualSQL)
	}
}

func TestSoftDeleteZeroValue(t *testing.T) {
	type SoftDeleteBook struct {
		ID        uint
		Name      string
		Pages     uint
		DeletedAt gorm.DeletedAt `gorm:"zeroValue:'1970-01-01 00:00:01'"`
	}
	DB.Migrator().DropTable(&SoftDeleteBook{})
	if err := DB.AutoMigrate(&SoftDeleteBook{}); err != nil {

    @Test
    void readRDataWireFormat_shouldHandleMultipleNames() throws Exception {
        // Test with maximum reasonable number of names
        int numNames = 10;
        int dataLength = 1 + (18 * numNames) + 6 + 6;
        byte[] src = new byte[dataLength];
        int srcIndex = 0;

        Field rDataLengthField = NameServicePacket.class.getDeclaredField("rDataLength");
        rDataLengthField.setAccessible(true);

        // Given
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, 1L, 0L);

        // When
        int size = request.size();

        // Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 4 bytes for cancel structure
        int expectedSize = ((Smb2Constants.SMB2_HEADER_LENGTH + 4 + 7) / 8) * 8;

	})
}

func (c chainG[T]) Delete(ctx context.Context) (rowsAffected int, err error) {
	r := new(T)
	res := c.g.apply(ctx).Delete(r)
	return int(res.RowsAffected), res.Error
}

func (c chainG[T]) Update(ctx context.Context, name string, value any) (rowsAffected int, err error) {
	var r T
	res := c.g.apply(ctx).Model(r).Update(name, value)
	return int(res.RowsAffected), res.Error
}

type ValueType int

// Different types of JSON value
const (
	Unknown ValueType = iota
	Null
	String
	Number
	Boolean
	Array
	Object
)

// MetaValue wraps a decoded interface value with the document
// position and depth at which the value was parsed
type MetaValue struct {
	Offset    int
	Length    int
	Depth     int
	Value     any
	ValueType ValueType
}

    }

    @Override
    public int getAccessMask() {
        return this.access;
    }

    @Override
    public SID getSID() {
        return this.sid;
    }

    @Override
    public int decode(final byte[] buf, int bi, final int len) {
        this.allow = buf[bi] == (byte) 0x00;
        bi++;
        this.flags = buf[bi++] & 0xFF;
        final int size = SMBUtil.readInt2(buf, bi);

        byte[] buffer = new byte[10];
        int result = sdd.readParameterWordsWireFormat(buffer, 0);
        assertEquals(0, result);
    }

    /**
     * Test readBytesWireFormat.
     */
    @Test
    void testReadBytesWireFormat() {
        SmbComDeleteDirectory sdd = new SmbComDeleteDirectory("testDir");
        byte[] buffer = new byte[10];
        int result = sdd.readBytesWireFormat(buffer, 0);

    private static final class Snippet {
        final int line;       // line of the [.multi-language-sample] header
        final Language lang;  // best-effort deduction (UNKNOWN allowed)

        Snippet(int line, Language lang) {
            this.line = line;
            this.lang = lang;
        }
    }

    private static final class Error {
        final int line;
        final String message;

  RegularImmutableTable() {}

  abstract Cell<R, C, V> getCell(int iterationIndex);

  @Override
  final ImmutableSet<Cell<R, C, V>> createCellSet() {
    return isEmpty() ? ImmutableSet.of() : new CellSet();
  }

  @WeakOuter
  private final class CellSet extends IndexedImmutableSet<Cell<R, C, V>> {
    @Override
    public int size() {
      return RegularImmutableTable.this.size();
    }

    @Override

	lru := lru.NewLRU[string, int](10, nil, time.Hour)
	lru.Add("key1", 1)
	lru.Add("key1", 2)

	if value, ok := lru.Get("key1"); !ok || value != 2 {
		t.Errorf("Expected value to be updated to 2, got %v", value)
	}
}

func TestLRU_Add_NewKey_AddsEntry(t *testing.T) {
	lru := lru.NewLRU[string, int](10, nil, time.Hour)
	lru.Add("key1", 1)