* the License.
 */

package com.google.common.cache;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.math.LongMath.saturatedAdd;
import static com.google.common.math.LongMath.saturatedSubtract;
import static java.lang.Math.max;

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.MoreObjects;
import java.util.Objects;

    for (int i = 0; i < 100000; i++) {
      assertEquals(LongMath.isPrime(i), IntMath.isPrime(i));
    }

    // Then check 1000 deterministic pseudo-random int values.
    Random rand = new Random(1);
    for (int i = 0; i < 1000; i++) {
      int n = rand.nextInt(Integer.MAX_VALUE);
      assertEquals(LongMath.isPrime(n), IntMath.isPrime(n));
    }
  }

  public void testSaturatedAbs() {

import static java.lang.Math.min;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.math.LongMath;
import java.util.concurrent.TimeUnit;

@J2ktIncompatible
@GwtIncompatible
abstract class SmoothRateLimiter extends RateLimiter {
  /*
   * How is the RateLimiter designed, and why?
   *

import com.google.common.base.Stopwatch;
import com.google.common.collect.ImmutableSet;
import com.google.common.hash.BloomFilterStrategies.LockFreeBitArray;
import com.google.common.math.LongMath;
import com.google.common.primitives.Ints;
import com.google.common.testing.EqualsTester;
import com.google.common.testing.NullPointerTester;
import com.google.common.testing.SerializableTester;

      // non-negative int, we can do long-arithmetic on index * (dataset.length - 1) / scale to get
      // a rounded ratio and a remainder which can be expressed as ints, without risk of overflow:
      int quotient = (int) LongMath.divide(numerator, scale, RoundingMode.DOWN);
      int remainder = (int) (numerator - (long) quotient * scale);
      selectInPlace(quotient, dataset, 0, dataset.length - 1);
      if (remainder == 0) {

            longPathBuilder.append("a");
        }
        String longPath = longPathBuilder.toString();

        Smb2TreeConnectRequest req = new Smb2TreeConnectRequest(mockConfig, longPath);
        byte[] buffer = new byte[4096];

        // When
        req.encode(buffer, 0);

        // Then
        byte[] pathBytes = longPath.getBytes(StandardCharsets.UTF_16LE);

        // Create a very long filename
        StringBuilder longPath = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            longPath.append("verylongpath/");
        }
        longPath.append("file.txt");

        trans2QueryPathInfo = new Trans2QueryPathInformation(config, longPath.toString(), TEST_INFO_LEVEL);

        byte[] buffer = new byte[8192]; // Large buffer for long path

    }

    @Test
    public void testPathTooLong() throws Exception {
        StringBuilder longPath = new StringBuilder("\\share");
        for (int i = 0; i < 100; i++) {
            longPath.append("\\verylongfoldername");
        }
        assertThrows(SmbException.class, () -> {
            validator.validatePath(longPath.toString());
        });
    }

    @Test

    }

    @Test
    @DisplayName("Test writeBytesWireFormat with long path")
    void testWriteBytesWireFormatLongPath() {
        String longPath = "very\\long\\path\\to\\some\\deeply\\nested\\file\\in\\directory\\structure.txt";
        request = new Smb2CreateRequest(mockConfig, longPath);

        byte[] buffer = new byte[2048];
        int bytesWritten = request.writeBytesWireFormat(buffer, 0);

            StringBuilder longPath = new StringBuilder("\\server\\share");
            for (int i = 0; i < 100; i++) {
                longPath.append("\\subfolder").append(i);
            }

            when(mockReferral.getTtl()).thenReturn(300);
            when(mockReferral.getRFlags()).thenReturn(0);
            when(mockReferral.getNode()).thenReturn(longPath.toString());