expected: []int{1, 2, 3},
		},
	}

	for _, testcase := range tests {
		t.Run(testcase.name, func(t *testing.T) {
			result := RTrimSlice(testcase.input, testcase.trimLen)
			if !AssertEqual(result, testcase.expected) {
				t.Errorf("RTrimSlice(%v, %d) = %v; want %v", testcase.input, testcase.trimLen, result, testcase.expected)
			}
		})
	}

    @Override
    public int hashCode() {
        int result = name.hashCode();
        result += 65599 * hexCode;
        result += 65599 * srcHashCode; /* hashCode is different depending
                                        * on where it came from
                                        */
        if (scope != null && scope.length() != 0) {
            result += scope.hashCode();
        }
        return result;
    }

	}
}

func TestDeletedAtUnMarshal(t *testing.T) {
	expected := &gorm.Model{}
	b, _ := json.Marshal(expected)

	result := &gorm.Model{}
	_ = json.Unmarshal(b, result)
	if result.DeletedAt != expected.DeletedAt {
		t.Errorf("Failed, result.DeletedAt: %v is not same as expected.DeletedAt: %v", result.DeletedAt, expected.DeletedAt)
	}
}

func TestDeletedAtOneOr(t *testing.T) {
	actualSQL := DB.ToSQL(func(tx *gorm.DB) *gorm.DB {

        try {
            Artifact artifact = new Artifact("invalid-prefix-simple", "1.0.0");
            String result = themeHelper.getThemeName(artifact);
            // May not throw exception but return unexpected result
            assertNotNull(result);
        } catch (Exception e) {
            assertTrue(true); // Expected exception
        }
    }

        assertFalse(it.hasNext());
        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("Name filter throwing CIFSException results in skip, not failure")
    void nameFilterThrowsIsHandled() throws Exception {
        // Arrange
        stubAcquireReturnsSelf();
        when(nameFilter.accept(parent, "bad")).thenThrow(new CIFSException("bad name"));

        int result = SMBUtil.readInt2(buffer, 0);
        assertEquals(expected & 0xFFFF, result);
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, 0xFFFFFFFFL, 0x12345678L, 0x80000000L })
    void testWriteReadInt4RoundTrip(long input) {
        byte[] buffer = new byte[8];
        SMBUtil.writeInt4(input, buffer, 0);
        int result = SMBUtil.readInt4(buffer, 0);

        }

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        PacDataInputStream pacStream = new PacDataInputStream(bais);

        String result = pacStream.readString();
        assertEquals(testString, result);
    }

    @Test
    @DisplayName("Test PacDataInputStream readString with empty string")
    void testReadEmptyString() throws Exception {

          return Optional.of(Long.MAX_VALUE);
        }
      }
      return Optional.of(result);
    }

    @Override
    public long size() throws IOException {
      long result = 0L;
      for (ByteSource source : sources) {
        result += source.size();
        if (result < 0) {
          // Overflow (or one or more sources that returned a negative size, but all bets are off in

    return delegate().submit(task);
  }

  @Override
  public <T extends @Nullable Object> ListenableFuture<T> submit(
      Runnable task, @ParametricNullness T result) {
    return delegate().submit(task, result);
  }

    }

    @Override
    public int hashCode() {
        int result = interfaceIndex;
        result = 31 * result + (address != null ? address.hashCode() : 0);
        return result;
    }