*/
  @DoNotCall("Use naturalOrder (which does not accept an expected size)")
  @Deprecated
  public static <K, V> ImmutableSortedMap.Builder<K, V> builderWithExpectedSize(int expectedSize) {
    throw new UnsupportedOperationException();
  }

  /**
   * Not supported. <b>You are attempting to create a map that may contain a non-{@code Comparable}

        void testSizeWithVariousCombinations(int algoCount, int saltSize, int expectedSize) {
            int[] hashAlgos = algoCount > 0 ? new int[algoCount] : null;
            byte[] salt = saltSize > 0 ? new byte[saltSize] : null;
            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            assertEquals(expectedSize, context.size());
        }

   */
  @DoNotCall("Use naturalOrder (which does not accept an expected size)")
  @Deprecated
  public static <K, V> ImmutableSortedMap.Builder<K, V> builderWithExpectedSize(int expectedSize) {
    throw new UnsupportedOperationException();
  }

  /**
   * Not supported. <b>You are attempting to create a map that may contain a non-{@code Comparable}

            assertEquals(400L, SMBUtil.readInt8(buffer, EXPECTED_SIZE));
            assertEquals(500L, SMBUtil.readInt8(buffer, EXPECTED_SIZE + 8));
            assertEquals(600, SMBUtil.readInt4(buffer, EXPECTED_SIZE + 16));

            // Verify third chunk
            assertEquals(700L, SMBUtil.readInt8(buffer, EXPECTED_SIZE * 2));
            assertEquals(800L, SMBUtil.readInt8(buffer, EXPECTED_SIZE * 2 + 8));

		modTimesThreeNone[i] = threeNanoSecs
	}

	testCases := []struct {
		modTimes       []time.Time
		expectedTime   time.Time
		errs           []error
		_tamperBackend tamperKind
	}{
		{
			modTimes:     modTimesThreeFour,
			expectedTime: threeNanoSecs,
			errs: []error{
				nil, nil, nil, nil, nil, nil, nil, nil,
				nil, nil, nil, nil, nil, nil, nil, nil,
			},

                        actualLines = Files.readAllLines(noticePath);
                        for (final String expectedLine : expectedLines) {
                            if (actualLines.contains(expectedLine) == false) {
                                throw new GradleException("expected [" + noticePath + " to contain [" + expectedLine + "] but it did not");
                            }
                        }

			gott, goterr := Parse(testCase.timeStr)
			if !errors.Is(goterr, testCase.expectedErr) {
				t.Errorf("expected %v, got %v", testCase.expectedErr, goterr)
			}
			if !gott.Equal(testCase.expectedTime) {
				t.Errorf("expected %v, got %v", testCase.expectedTime, gott)
			}
		})
	}

        // This is the expected behavior for Windows FILETIME
        long expectedTime = -11644473600000L; // Jan 1, 1601 in Unix time
        assertEquals(expectedTime, decoded.getCreateTime());
        assertEquals(expectedTime, decoded.getLastAccessTime());
        assertEquals(expectedTime, decoded.getLastWriteTime());
        assertEquals(0, decoded.getAttributes());
    }

    @Test

            @Override
            public long getCurrentTimeAsLong() {
                // Return consistent time for testing
                if (expectedTime[0] == 0) {
                    expectedTime[0] = System.currentTimeMillis();
                }
                return expectedTime[0];
            }
        };

        FessConfig fessConfig = new TestFessConfig() {
            @Override

        }

        @Test
        void testLastModified() throws SmbException {
            // Arrange
            long expectedTime = System.currentTimeMillis();
            doReturn(expectedTime).when(smbFile).lastModified();

            // Act & Assert
            assertEquals(expectedTime, smbFile.lastModified());
        }

        @Test
        void testSetLastModified() throws SmbException {