assertEquals(100, InputValidator.safeAdd(50, 50));
        assertEquals(0, InputValidator.safeAdd(-50, 50));

        assertThrows(ArithmeticException.class, () -> InputValidator.safeAdd(Integer.MAX_VALUE, 1));
        assertThrows(ArithmeticException.class, () -> InputValidator.safeAdd(Integer.MIN_VALUE, -1));
    }

    @Test
    @DisplayName("Test safe integer multiplication")
    void testSafeMultiplication() {

            String s = policy.substring(UPDATE_POLICY_INTERVAL.length() + 1);
            return Integer.parseInt(s);
        } else {
            return Integer.MAX_VALUE;
        }
    }

        settings.set(key, value);
        assertEquals(value, settings.getAsInt(key, -1));
    }

    @Test
    public void test_setAndGetAsLong() {
        String key = "key";
        long value = Long.MAX_VALUE;
        settings.set(key, value);
        assertEquals(value, settings.getAsLong(key, -1));
    }

    @Test
    public void test_setAndGetAsFloat() {
        String key = "key";

    }

    /**
     * Parameterised test for a selection of edge and typical values.
     */
    @ParameterizedTest(name = "Encode and decode {0}")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE })
    public void testEncodeWithVariousValues(long val) throws NdrException {
        NdrHyper hyper = new NdrHyper(val);
        // Create buffer with extra space for alignment

      new float[] {
        LEAST,
        -Float.MAX_VALUE,
        -1f,
        -0f,
        0f,
        1f,
        Float.MAX_VALUE,
        GREATEST,
        Float.MIN_NORMAL,
        -Float.MIN_NORMAL,
        Float.MIN_VALUE,
        -Float.MIN_VALUE,
        Integer.MIN_VALUE,
        Integer.MAX_VALUE,
        Long.MIN_VALUE,
        Long.MAX_VALUE
      };

      new float[] {
        LEAST,
        -Float.MAX_VALUE,
        -1f,
        -0f,
        0f,
        1f,
        Float.MAX_VALUE,
        GREATEST,
        Float.MIN_NORMAL,
        -Float.MIN_NORMAL,
        Float.MIN_VALUE,
        -Float.MIN_VALUE,
        Integer.MIN_VALUE,
        Integer.MAX_VALUE,
        Long.MIN_VALUE,
        Long.MAX_VALUE
      };

        }

        @Test
        @DisplayName("Should handle locks with maximum values")
        void testLocksWithMaximumValues() {
            Smb2Lock[] locks = new Smb2Lock[] { new Smb2Lock(Long.MAX_VALUE, Long.MAX_VALUE, Integer.MAX_VALUE) };

            Smb2LockRequest req = new Smb2LockRequest(mockConfig, testFileId, locks);
            byte[] buffer = new byte[256];

  }

  fun getMaxConcurrentStreams(): Int {
    val bit = 1 shl MAX_CONCURRENT_STREAMS
    return if (bit and set != 0) values[MAX_CONCURRENT_STREAMS] else Int.MAX_VALUE
  }

  fun getMaxFrameSize(defaultValue: Int): Int {
    val bit = 1 shl MAX_FRAME_SIZE
    return if (bit and set != 0) values[MAX_FRAME_SIZE] else defaultValue
  }

      }
    } catch (ArithmeticException e) {
      throw new IllegalArgumentException(
          "Cartesian product too large; must have size at most Integer.MAX_VALUE");
    }
    this.axesSizeProduct = axesSizeProduct;
  }

  private int getAxisIndexForProductIndex(int index, int axis) {
    return (index / axesSizeProduct[axis + 1]) % axes.get(axis).size();
  }

  private static final char[] ARRAY234 = {(char) 2, (char) 3, (char) 4};

  private static final char LEAST = Character.MIN_VALUE;
  private static final char GREATEST = Character.MAX_VALUE;

  private static final char[] VALUES = {LEAST, 'a', '\u00e0', '\udcaa', GREATEST};

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")