ceph/src/rocksdb/java/src/test/java/org/rocksdb/OptionsTest.java

   1 // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 //  This source code is licensed under both the GPLv2 (found in the
   3 //  COPYING file in the root directory) and Apache 2.0 License
   4 //  (found in the LICENSE.Apache file in the root directory).
   5
   6 package org.rocksdb;
   7
   8 import java.nio.file.Paths;
   9 import java.util.*;
  10
  11 import org.junit.ClassRule;
  12 import org.junit.Test;
  13 import org.rocksdb.test.RemoveEmptyValueCompactionFilterFactory;
  14
  15 import static org.assertj.core.api.Assertions.assertThat;
  16
  17
  18 public class OptionsTest {
  19
  20   @ClassRule
  21   public static final RocksNativeLibraryResource ROCKS_NATIVE_LIBRARY_RESOURCE =
  22       new RocksNativeLibraryResource();
  23
  24   public static final Random rand = PlatformRandomHelper.
  25       getPlatformSpecificRandomFactory();
  26
  27   @Test
  28   public void copyConstructor() {
  29     Options origOpts = new Options();
  30     origOpts.setNumLevels(rand.nextInt(8));
  31     origOpts.setTargetFileSizeMultiplier(rand.nextInt(100));
  32     origOpts.setLevel0StopWritesTrigger(rand.nextInt(50));
  33     Options copyOpts = new Options(origOpts);
  34     assertThat(origOpts.numLevels()).isEqualTo(copyOpts.numLevels());
  35     assertThat(origOpts.targetFileSizeMultiplier()).isEqualTo(copyOpts.targetFileSizeMultiplier());
  36     assertThat(origOpts.level0StopWritesTrigger()).isEqualTo(copyOpts.level0StopWritesTrigger());
  37   }
  38
  39   @Test
  40   public void setIncreaseParallelism() {
  41     try (final Options opt = new Options()) {
  42       final int threads = Runtime.getRuntime().availableProcessors() * 2;
  43       opt.setIncreaseParallelism(threads);
  44     }
  45   }
  46
  47   @Test
  48   public void writeBufferSize() throws RocksDBException {
  49     try (final Options opt = new Options()) {
  50       final long longValue = rand.nextLong();
  51       opt.setWriteBufferSize(longValue);
  52       assertThat(opt.writeBufferSize()).isEqualTo(longValue);
  53     }
  54   }
  55
  56   @Test
  57   public void maxWriteBufferNumber() {
  58     try (final Options opt = new Options()) {
  59       final int intValue = rand.nextInt();
  60       opt.setMaxWriteBufferNumber(intValue);
  61       assertThat(opt.maxWriteBufferNumber()).isEqualTo(intValue);
  62     }
  63   }
  64
  65   @Test
  66   public void minWriteBufferNumberToMerge() {
  67     try (final Options opt = new Options()) {
  68       final int intValue = rand.nextInt();
  69       opt.setMinWriteBufferNumberToMerge(intValue);
  70       assertThat(opt.minWriteBufferNumberToMerge()).isEqualTo(intValue);
  71     }
  72   }
  73
  74   @Test
  75   public void numLevels() {
  76     try (final Options opt = new Options()) {
  77       final int intValue = rand.nextInt();
  78       opt.setNumLevels(intValue);
  79       assertThat(opt.numLevels()).isEqualTo(intValue);
  80     }
  81   }
  82
  83   @Test
  84   public void levelZeroFileNumCompactionTrigger() {
  85     try (final Options opt = new Options()) {
  86       final int intValue = rand.nextInt();
  87       opt.setLevelZeroFileNumCompactionTrigger(intValue);
  88       assertThat(opt.levelZeroFileNumCompactionTrigger()).isEqualTo(intValue);
  89     }
  90   }
  91
  92   @Test
  93   public void levelZeroSlowdownWritesTrigger() {
  94     try (final Options opt = new Options()) {
  95       final int intValue = rand.nextInt();
  96       opt.setLevelZeroSlowdownWritesTrigger(intValue);
  97       assertThat(opt.levelZeroSlowdownWritesTrigger()).isEqualTo(intValue);
  98     }
  99   }
 100
 101   @Test
 102   public void levelZeroStopWritesTrigger() {
 103     try (final Options opt = new Options()) {
 104       final int intValue = rand.nextInt();
 105       opt.setLevelZeroStopWritesTrigger(intValue);
 106       assertThat(opt.levelZeroStopWritesTrigger()).isEqualTo(intValue);
 107     }
 108   }
 109
 110   @Test
 111   public void targetFileSizeBase() {
 112     try (final Options opt = new Options()) {
 113       final long longValue = rand.nextLong();
 114       opt.setTargetFileSizeBase(longValue);
 115       assertThat(opt.targetFileSizeBase()).isEqualTo(longValue);
 116     }
 117   }
 118
 119   @Test
 120   public void targetFileSizeMultiplier() {
 121     try (final Options opt = new Options()) {
 122       final int intValue = rand.nextInt();
 123       opt.setTargetFileSizeMultiplier(intValue);
 124       assertThat(opt.targetFileSizeMultiplier()).isEqualTo(intValue);
 125     }
 126   }
 127
 128   @Test
 129   public void maxBytesForLevelBase() {
 130     try (final Options opt = new Options()) {
 131       final long longValue = rand.nextLong();
 132       opt.setMaxBytesForLevelBase(longValue);
 133       assertThat(opt.maxBytesForLevelBase()).isEqualTo(longValue);
 134     }
 135   }
 136
 137   @Test
 138   public void levelCompactionDynamicLevelBytes() {
 139     try (final Options opt = new Options()) {
 140       final boolean boolValue = rand.nextBoolean();
 141       opt.setLevelCompactionDynamicLevelBytes(boolValue);
 142       assertThat(opt.levelCompactionDynamicLevelBytes())
 143           .isEqualTo(boolValue);
 144     }
 145   }
 146
 147   @Test
 148   public void maxBytesForLevelMultiplier() {
 149     try (final Options opt = new Options()) {
 150       final double doubleValue = rand.nextDouble();
 151       opt.setMaxBytesForLevelMultiplier(doubleValue);
 152       assertThat(opt.maxBytesForLevelMultiplier()).isEqualTo(doubleValue);
 153     }
 154   }
 155
 156   @Test
 157   public void maxBytesForLevelMultiplierAdditional() {
 158     try (final Options opt = new Options()) {
 159       final int intValue1 = rand.nextInt();
 160       final int intValue2 = rand.nextInt();
 161       final int[] ints = new int[]{intValue1, intValue2};
 162       opt.setMaxBytesForLevelMultiplierAdditional(ints);
 163       assertThat(opt.maxBytesForLevelMultiplierAdditional()).isEqualTo(ints);
 164     }
 165   }
 166
 167   @Test
 168   public void maxCompactionBytes() {
 169     try (final Options opt = new Options()) {
 170       final long longValue = rand.nextLong();
 171       opt.setMaxCompactionBytes(longValue);
 172       assertThat(opt.maxCompactionBytes()).isEqualTo(longValue);
 173     }
 174   }
 175
 176   @Test
 177   public void softPendingCompactionBytesLimit() {
 178     try (final Options opt = new Options()) {
 179       final long longValue = rand.nextLong();
 180       opt.setSoftPendingCompactionBytesLimit(longValue);
 181       assertThat(opt.softPendingCompactionBytesLimit()).isEqualTo(longValue);
 182     }
 183   }
 184
 185   @Test
 186   public void hardPendingCompactionBytesLimit() {
 187     try (final Options opt = new Options()) {
 188       final long longValue = rand.nextLong();
 189       opt.setHardPendingCompactionBytesLimit(longValue);
 190       assertThat(opt.hardPendingCompactionBytesLimit()).isEqualTo(longValue);
 191     }
 192   }
 193
 194   @Test
 195   public void level0FileNumCompactionTrigger() {
 196     try (final Options opt = new Options()) {
 197       final int intValue = rand.nextInt();
 198       opt.setLevel0FileNumCompactionTrigger(intValue);
 199       assertThat(opt.level0FileNumCompactionTrigger()).isEqualTo(intValue);
 200     }
 201   }
 202
 203   @Test
 204   public void level0SlowdownWritesTrigger() {
 205     try (final Options opt = new Options()) {
 206       final int intValue = rand.nextInt();
 207       opt.setLevel0SlowdownWritesTrigger(intValue);
 208       assertThat(opt.level0SlowdownWritesTrigger()).isEqualTo(intValue);
 209     }
 210   }
 211
 212   @Test
 213   public void level0StopWritesTrigger() {
 214     try (final Options opt = new Options()) {
 215       final int intValue = rand.nextInt();
 216       opt.setLevel0StopWritesTrigger(intValue);
 217       assertThat(opt.level0StopWritesTrigger()).isEqualTo(intValue);
 218     }
 219   }
 220
 221   @Test
 222   public void arenaBlockSize() throws RocksDBException {
 223     try (final Options opt = new Options()) {
 224       final long longValue = rand.nextLong();
 225       opt.setArenaBlockSize(longValue);
 226       assertThat(opt.arenaBlockSize()).isEqualTo(longValue);
 227     }
 228   }
 229
 230   @Test
 231   public void disableAutoCompactions() {
 232     try (final Options opt = new Options()) {
 233       final boolean boolValue = rand.nextBoolean();
 234       opt.setDisableAutoCompactions(boolValue);
 235       assertThat(opt.disableAutoCompactions()).isEqualTo(boolValue);
 236     }
 237   }
 238
 239   @Test
 240   public void maxSequentialSkipInIterations() {
 241     try (final Options opt = new Options()) {
 242       final long longValue = rand.nextLong();
 243       opt.setMaxSequentialSkipInIterations(longValue);
 244       assertThat(opt.maxSequentialSkipInIterations()).isEqualTo(longValue);
 245     }
 246   }
 247
 248   @Test
 249   public void inplaceUpdateSupport() {
 250     try (final Options opt = new Options()) {
 251       final boolean boolValue = rand.nextBoolean();
 252       opt.setInplaceUpdateSupport(boolValue);
 253       assertThat(opt.inplaceUpdateSupport()).isEqualTo(boolValue);
 254     }
 255   }
 256
 257   @Test
 258   public void inplaceUpdateNumLocks() throws RocksDBException {
 259     try (final Options opt = new Options()) {
 260       final long longValue = rand.nextLong();
 261       opt.setInplaceUpdateNumLocks(longValue);
 262       assertThat(opt.inplaceUpdateNumLocks()).isEqualTo(longValue);
 263     }
 264   }
 265
 266   @Test
 267   public void memtablePrefixBloomSizeRatio() {
 268     try (final Options opt = new Options()) {
 269       final double doubleValue = rand.nextDouble();
 270       opt.setMemtablePrefixBloomSizeRatio(doubleValue);
 271       assertThat(opt.memtablePrefixBloomSizeRatio()).isEqualTo(doubleValue);
 272     }
 273   }
 274
 275   @Test
 276   public void memtableHugePageSize() {
 277     try (final Options opt = new Options()) {
 278       final long longValue = rand.nextLong();
 279       opt.setMemtableHugePageSize(longValue);
 280       assertThat(opt.memtableHugePageSize()).isEqualTo(longValue);
 281     }
 282   }
 283
 284   @Test
 285   public void bloomLocality() {
 286     try (final Options opt = new Options()) {
 287       final int intValue = rand.nextInt();
 288       opt.setBloomLocality(intValue);
 289       assertThat(opt.bloomLocality()).isEqualTo(intValue);
 290     }
 291   }
 292
 293   @Test
 294   public void maxSuccessiveMerges() throws RocksDBException {
 295     try (final Options opt = new Options()) {
 296       final long longValue = rand.nextLong();
 297       opt.setMaxSuccessiveMerges(longValue);
 298       assertThat(opt.maxSuccessiveMerges()).isEqualTo(longValue);
 299     }
 300   }
 301
 302   @Test
 303   public void optimizeFiltersForHits() {
 304     try (final Options opt = new Options()) {
 305       final boolean aBoolean = rand.nextBoolean();
 306       opt.setOptimizeFiltersForHits(aBoolean);
 307       assertThat(opt.optimizeFiltersForHits()).isEqualTo(aBoolean);
 308     }
 309   }
 310
 311   @Test
 312   public void createIfMissing() {
 313     try (final Options opt = new Options()) {
 314       final boolean boolValue = rand.nextBoolean();
 315       opt.setCreateIfMissing(boolValue);
 316       assertThat(opt.createIfMissing()).
 317           isEqualTo(boolValue);
 318     }
 319   }
 320
 321   @Test
 322   public void createMissingColumnFamilies() {
 323     try (final Options opt = new Options()) {
 324       final boolean boolValue = rand.nextBoolean();
 325       opt.setCreateMissingColumnFamilies(boolValue);
 326       assertThat(opt.createMissingColumnFamilies()).
 327           isEqualTo(boolValue);
 328     }
 329   }
 330
 331   @Test
 332   public void errorIfExists() {
 333     try (final Options opt = new Options()) {
 334       final boolean boolValue = rand.nextBoolean();
 335       opt.setErrorIfExists(boolValue);
 336       assertThat(opt.errorIfExists()).isEqualTo(boolValue);
 337     }
 338   }
 339
 340   @Test
 341   public void paranoidChecks() {
 342     try (final Options opt = new Options()) {
 343       final boolean boolValue = rand.nextBoolean();
 344       opt.setParanoidChecks(boolValue);
 345       assertThat(opt.paranoidChecks()).
 346           isEqualTo(boolValue);
 347     }
 348   }
 349
 350   @Test
 351   public void maxTotalWalSize() {
 352     try (final Options opt = new Options()) {
 353       final long longValue = rand.nextLong();
 354       opt.setMaxTotalWalSize(longValue);
 355       assertThat(opt.maxTotalWalSize()).
 356           isEqualTo(longValue);
 357     }
 358   }
 359
 360   @Test
 361   public void maxOpenFiles() {
 362     try (final Options opt = new Options()) {
 363       final int intValue = rand.nextInt();
 364       opt.setMaxOpenFiles(intValue);
 365       assertThat(opt.maxOpenFiles()).isEqualTo(intValue);
 366     }
 367   }
 368
 369   @Test
 370   public void maxFileOpeningThreads() {
 371     try (final Options opt = new Options()) {
 372       final int intValue = rand.nextInt();
 373       opt.setMaxFileOpeningThreads(intValue);
 374       assertThat(opt.maxFileOpeningThreads()).isEqualTo(intValue);
 375     }
 376   }
 377
 378   @Test
 379   public void useFsync() {
 380     try (final Options opt = new Options()) {
 381       final boolean boolValue = rand.nextBoolean();
 382       opt.setUseFsync(boolValue);
 383       assertThat(opt.useFsync()).isEqualTo(boolValue);
 384     }
 385   }
 386
 387   @Test
 388   public void dbPaths() {
 389     final List<DbPath> dbPaths = new ArrayList<>();
 390     dbPaths.add(new DbPath(Paths.get("/a"), 10));
 391     dbPaths.add(new DbPath(Paths.get("/b"), 100));
 392     dbPaths.add(new DbPath(Paths.get("/c"), 1000));
 393
 394     try (final Options opt = new Options()) {
 395       assertThat(opt.dbPaths()).isEqualTo(Collections.emptyList());
 396
 397       opt.setDbPaths(dbPaths);
 398
 399       assertThat(opt.dbPaths()).isEqualTo(dbPaths);
 400     }
 401   }
 402
 403   @Test
 404   public void dbLogDir() {
 405     try (final Options opt = new Options()) {
 406       final String str = "path/to/DbLogDir";
 407       opt.setDbLogDir(str);
 408       assertThat(opt.dbLogDir()).isEqualTo(str);
 409     }
 410   }
 411
 412   @Test
 413   public void walDir() {
 414     try (final Options opt = new Options()) {
 415       final String str = "path/to/WalDir";
 416       opt.setWalDir(str);
 417       assertThat(opt.walDir()).isEqualTo(str);
 418     }
 419   }
 420
 421   @Test
 422   public void deleteObsoleteFilesPeriodMicros() {
 423     try (final Options opt = new Options()) {
 424       final long longValue = rand.nextLong();
 425       opt.setDeleteObsoleteFilesPeriodMicros(longValue);
 426       assertThat(opt.deleteObsoleteFilesPeriodMicros()).
 427           isEqualTo(longValue);
 428     }
 429   }
 430
 431   @SuppressWarnings("deprecated")
 432   @Test
 433   public void baseBackgroundCompactions() {
 434     try (final Options opt = new Options()) {
 435       final int intValue = rand.nextInt();
 436       opt.setBaseBackgroundCompactions(intValue);
 437       assertThat(opt.baseBackgroundCompactions()).
 438           isEqualTo(intValue);
 439     }
 440   }
 441
 442   @SuppressWarnings("deprecated")
 443   @Test
 444   public void maxBackgroundCompactions() {
 445     try (final Options opt = new Options()) {
 446       final int intValue = rand.nextInt();
 447       opt.setMaxBackgroundCompactions(intValue);
 448       assertThat(opt.maxBackgroundCompactions()).
 449           isEqualTo(intValue);
 450     }
 451   }
 452
 453   @Test
 454   public void maxSubcompactions() {
 455     try (final Options opt = new Options()) {
 456       final int intValue = rand.nextInt();
 457       opt.setMaxSubcompactions(intValue);
 458       assertThat(opt.maxSubcompactions()).
 459           isEqualTo(intValue);
 460     }
 461   }
 462
 463   @SuppressWarnings("deprecated")
 464   @Test
 465   public void maxBackgroundFlushes() {
 466     try (final Options opt = new Options()) {
 467       final int intValue = rand.nextInt();
 468       opt.setMaxBackgroundFlushes(intValue);
 469       assertThat(opt.maxBackgroundFlushes()).
 470           isEqualTo(intValue);
 471     }
 472   }
 473
 474   @Test
 475   public void maxBackgroundJobs() {
 476     try (final Options opt = new Options()) {
 477       final int intValue = rand.nextInt();
 478       opt.setMaxBackgroundJobs(intValue);
 479       assertThat(opt.maxBackgroundJobs()).isEqualTo(intValue);
 480     }
 481   }
 482
 483   @Test
 484   public void maxLogFileSize() throws RocksDBException {
 485     try (final Options opt = new Options()) {
 486       final long longValue = rand.nextLong();
 487       opt.setMaxLogFileSize(longValue);
 488       assertThat(opt.maxLogFileSize()).isEqualTo(longValue);
 489     }
 490   }
 491
 492   @Test
 493   public void logFileTimeToRoll() throws RocksDBException {
 494     try (final Options opt = new Options()) {
 495       final long longValue = rand.nextLong();
 496       opt.setLogFileTimeToRoll(longValue);
 497       assertThat(opt.logFileTimeToRoll()).
 498           isEqualTo(longValue);
 499     }
 500   }
 501
 502   @Test
 503   public void keepLogFileNum() throws RocksDBException {
 504     try (final Options opt = new Options()) {
 505       final long longValue = rand.nextLong();
 506       opt.setKeepLogFileNum(longValue);
 507       assertThat(opt.keepLogFileNum()).isEqualTo(longValue);
 508     }
 509   }
 510
 511   @Test
 512   public void recycleLogFileNum() throws RocksDBException {
 513     try (final Options opt = new Options()) {
 514       final long longValue = rand.nextLong();
 515       opt.setRecycleLogFileNum(longValue);
 516       assertThat(opt.recycleLogFileNum()).isEqualTo(longValue);
 517     }
 518   }
 519
 520   @Test
 521   public void maxManifestFileSize() {
 522     try (final Options opt = new Options()) {
 523       final long longValue = rand.nextLong();
 524       opt.setMaxManifestFileSize(longValue);
 525       assertThat(opt.maxManifestFileSize()).
 526           isEqualTo(longValue);
 527     }
 528   }
 529
 530   @Test
 531   public void tableCacheNumshardbits() {
 532     try (final Options opt = new Options()) {
 533       final int intValue = rand.nextInt();
 534       opt.setTableCacheNumshardbits(intValue);
 535       assertThat(opt.tableCacheNumshardbits()).
 536           isEqualTo(intValue);
 537     }
 538   }
 539
 540   @Test
 541   public void walSizeLimitMB() {
 542     try (final Options opt = new Options()) {
 543       final long longValue = rand.nextLong();
 544       opt.setWalSizeLimitMB(longValue);
 545       assertThat(opt.walSizeLimitMB()).isEqualTo(longValue);
 546     }
 547   }
 548
 549   @Test
 550   public void walTtlSeconds() {
 551     try (final Options opt = new Options()) {
 552       final long longValue = rand.nextLong();
 553       opt.setWalTtlSeconds(longValue);
 554       assertThat(opt.walTtlSeconds()).isEqualTo(longValue);
 555     }
 556   }
 557
 558   @Test
 559   public void manifestPreallocationSize() throws RocksDBException {
 560     try (final Options opt = new Options()) {
 561       final long longValue = rand.nextLong();
 562       opt.setManifestPreallocationSize(longValue);
 563       assertThat(opt.manifestPreallocationSize()).
 564           isEqualTo(longValue);
 565     }
 566   }
 567
 568   @Test
 569   public void useDirectReads() {
 570     try(final Options opt = new Options()) {
 571       final boolean boolValue = rand.nextBoolean();
 572       opt.setUseDirectReads(boolValue);
 573       assertThat(opt.useDirectReads()).isEqualTo(boolValue);
 574     }
 575   }
 576
 577   @Test
 578   public void useDirectIoForFlushAndCompaction() {
 579     try(final Options opt = new Options()) {
 580       final boolean boolValue = rand.nextBoolean();
 581       opt.setUseDirectIoForFlushAndCompaction(boolValue);
 582       assertThat(opt.useDirectIoForFlushAndCompaction()).isEqualTo(boolValue);
 583     }
 584   }
 585
 586   @Test
 587   public void allowFAllocate() {
 588     try (final Options opt = new Options()) {
 589       final boolean boolValue = rand.nextBoolean();
 590       opt.setAllowFAllocate(boolValue);
 591       assertThat(opt.allowFAllocate()).isEqualTo(boolValue);
 592     }
 593   }
 594
 595   @Test
 596   public void allowMmapReads() {
 597     try (final Options opt = new Options()) {
 598       final boolean boolValue = rand.nextBoolean();
 599       opt.setAllowMmapReads(boolValue);
 600       assertThat(opt.allowMmapReads()).isEqualTo(boolValue);
 601     }
 602   }
 603
 604   @Test
 605   public void allowMmapWrites() {
 606     try (final Options opt = new Options()) {
 607       final boolean boolValue = rand.nextBoolean();
 608       opt.setAllowMmapWrites(boolValue);
 609       assertThat(opt.allowMmapWrites()).isEqualTo(boolValue);
 610     }
 611   }
 612
 613   @Test
 614   public void isFdCloseOnExec() {
 615     try (final Options opt = new Options()) {
 616       final boolean boolValue = rand.nextBoolean();
 617       opt.setIsFdCloseOnExec(boolValue);
 618       assertThat(opt.isFdCloseOnExec()).isEqualTo(boolValue);
 619     }
 620   }
 621
 622   @Test
 623   public void statsDumpPeriodSec() {
 624     try (final Options opt = new Options()) {
 625       final int intValue = rand.nextInt();
 626       opt.setStatsDumpPeriodSec(intValue);
 627       assertThat(opt.statsDumpPeriodSec()).isEqualTo(intValue);
 628     }
 629   }
 630
 631   @Test
 632   public void statsPersistPeriodSec() {
 633     try (final Options opt = new Options()) {
 634       final int intValue = rand.nextInt();
 635       opt.setStatsPersistPeriodSec(intValue);
 636       assertThat(opt.statsPersistPeriodSec()).isEqualTo(intValue);
 637     }
 638   }
 639
 640   @Test
 641   public void statsHistoryBufferSize() {
 642     try (final Options opt = new Options()) {
 643       final long longValue = rand.nextLong();
 644       opt.setStatsHistoryBufferSize(longValue);
 645       assertThat(opt.statsHistoryBufferSize()).isEqualTo(longValue);
 646     }
 647   }
 648
 649   @Test
 650   public void adviseRandomOnOpen() {
 651     try (final Options opt = new Options()) {
 652       final boolean boolValue = rand.nextBoolean();
 653       opt.setAdviseRandomOnOpen(boolValue);
 654       assertThat(opt.adviseRandomOnOpen()).isEqualTo(boolValue);
 655     }
 656   }
 657
 658   @Test
 659   public void dbWriteBufferSize() {
 660     try (final Options opt = new Options()) {
 661       final long longValue = rand.nextLong();
 662       opt.setDbWriteBufferSize(longValue);
 663       assertThat(opt.dbWriteBufferSize()).isEqualTo(longValue);
 664     }
 665   }
 666
 667   @Test
 668   public void setWriteBufferManager() throws RocksDBException {
 669     try (final Options opt = new Options();
 670          final Cache cache = new LRUCache(1 * 1024 * 1024);
 671          final WriteBufferManager writeBufferManager = new WriteBufferManager(2000l, cache)) {
 672       opt.setWriteBufferManager(writeBufferManager);
 673       assertThat(opt.writeBufferManager()).isEqualTo(writeBufferManager);
 674     }
 675   }
 676
 677   @Test
 678   public void setWriteBufferManagerWithZeroBufferSize() throws RocksDBException {
 679     try (final Options opt = new Options();
 680          final Cache cache = new LRUCache(1 * 1024 * 1024);
 681          final WriteBufferManager writeBufferManager = new WriteBufferManager(0l, cache)) {
 682       opt.setWriteBufferManager(writeBufferManager);
 683       assertThat(opt.writeBufferManager()).isEqualTo(writeBufferManager);
 684     }
 685   }
 686
 687   @Test
 688   public void accessHintOnCompactionStart() {
 689     try (final Options opt = new Options()) {
 690       final AccessHint accessHint = AccessHint.SEQUENTIAL;
 691       opt.setAccessHintOnCompactionStart(accessHint);
 692       assertThat(opt.accessHintOnCompactionStart()).isEqualTo(accessHint);
 693     }
 694   }
 695
 696   @Test
 697   public void newTableReaderForCompactionInputs() {
 698     try (final Options opt = new Options()) {
 699       final boolean boolValue = rand.nextBoolean();
 700       opt.setNewTableReaderForCompactionInputs(boolValue);
 701       assertThat(opt.newTableReaderForCompactionInputs()).isEqualTo(boolValue);
 702     }
 703   }
 704
 705   @Test
 706   public void compactionReadaheadSize() {
 707     try (final Options opt = new Options()) {
 708       final long longValue = rand.nextLong();
 709       opt.setCompactionReadaheadSize(longValue);
 710       assertThat(opt.compactionReadaheadSize()).isEqualTo(longValue);
 711     }
 712   }
 713
 714   @Test
 715   public void randomAccessMaxBufferSize() {
 716     try (final Options opt = new Options()) {
 717       final long longValue = rand.nextLong();
 718       opt.setRandomAccessMaxBufferSize(longValue);
 719       assertThat(opt.randomAccessMaxBufferSize()).isEqualTo(longValue);
 720     }
 721   }
 722
 723   @Test
 724   public void writableFileMaxBufferSize() {
 725     try (final Options opt = new Options()) {
 726       final long longValue = rand.nextLong();
 727       opt.setWritableFileMaxBufferSize(longValue);
 728       assertThat(opt.writableFileMaxBufferSize()).isEqualTo(longValue);
 729     }
 730   }
 731
 732   @Test
 733   public void useAdaptiveMutex() {
 734     try (final Options opt = new Options()) {
 735       final boolean boolValue = rand.nextBoolean();
 736       opt.setUseAdaptiveMutex(boolValue);
 737       assertThat(opt.useAdaptiveMutex()).isEqualTo(boolValue);
 738     }
 739   }
 740
 741   @Test
 742   public void bytesPerSync() {
 743     try (final Options opt = new Options()) {
 744       final long longValue = rand.nextLong();
 745       opt.setBytesPerSync(longValue);
 746       assertThat(opt.bytesPerSync()).isEqualTo(longValue);
 747     }
 748   }
 749
 750   @Test
 751   public void walBytesPerSync() {
 752     try (final Options opt = new Options()) {
 753       final long longValue = rand.nextLong();
 754       opt.setWalBytesPerSync(longValue);
 755       assertThat(opt.walBytesPerSync()).isEqualTo(longValue);
 756     }
 757   }
 758
 759   @Test
 760   public void strictBytesPerSync() {
 761     try (final Options opt = new Options()) {
 762       assertThat(opt.strictBytesPerSync()).isFalse();
 763       opt.setStrictBytesPerSync(true);
 764       assertThat(opt.strictBytesPerSync()).isTrue();
 765     }
 766   }
 767
 768   @Test
 769   public void enableThreadTracking() {
 770     try (final Options opt = new Options()) {
 771       final boolean boolValue = rand.nextBoolean();
 772       opt.setEnableThreadTracking(boolValue);
 773       assertThat(opt.enableThreadTracking()).isEqualTo(boolValue);
 774     }
 775   }
 776
 777   @Test
 778   public void delayedWriteRate() {
 779     try (final Options opt = new Options()) {
 780       final long longValue = rand.nextLong();
 781       opt.setDelayedWriteRate(longValue);
 782       assertThat(opt.delayedWriteRate()).isEqualTo(longValue);
 783     }
 784   }
 785
 786   @Test
 787   public void enablePipelinedWrite() {
 788     try(final Options opt = new Options()) {
 789       assertThat(opt.enablePipelinedWrite()).isFalse();
 790       opt.setEnablePipelinedWrite(true);
 791       assertThat(opt.enablePipelinedWrite()).isTrue();
 792     }
 793   }
 794
 795   @Test
 796   public void unordredWrite() {
 797     try(final Options opt = new Options()) {
 798       assertThat(opt.unorderedWrite()).isFalse();
 799       opt.setUnorderedWrite(true);
 800       assertThat(opt.unorderedWrite()).isTrue();
 801     }
 802   }
 803
 804   @Test
 805   public void allowConcurrentMemtableWrite() {
 806     try (final Options opt = new Options()) {
 807       final boolean boolValue = rand.nextBoolean();
 808       opt.setAllowConcurrentMemtableWrite(boolValue);
 809       assertThat(opt.allowConcurrentMemtableWrite()).isEqualTo(boolValue);
 810     }
 811   }
 812
 813   @Test
 814   public void enableWriteThreadAdaptiveYield() {
 815     try (final Options opt = new Options()) {
 816       final boolean boolValue = rand.nextBoolean();
 817       opt.setEnableWriteThreadAdaptiveYield(boolValue);
 818       assertThat(opt.enableWriteThreadAdaptiveYield()).isEqualTo(boolValue);
 819     }
 820   }
 821
 822   @Test
 823   public void writeThreadMaxYieldUsec() {
 824     try (final Options opt = new Options()) {
 825       final long longValue = rand.nextLong();
 826       opt.setWriteThreadMaxYieldUsec(longValue);
 827       assertThat(opt.writeThreadMaxYieldUsec()).isEqualTo(longValue);
 828     }
 829   }
 830
 831   @Test
 832   public void writeThreadSlowYieldUsec() {
 833     try (final Options opt = new Options()) {
 834       final long longValue = rand.nextLong();
 835       opt.setWriteThreadSlowYieldUsec(longValue);
 836       assertThat(opt.writeThreadSlowYieldUsec()).isEqualTo(longValue);
 837     }
 838   }
 839
 840   @Test
 841   public void skipStatsUpdateOnDbOpen() {
 842     try (final Options opt = new Options()) {
 843       final boolean boolValue = rand.nextBoolean();
 844       opt.setSkipStatsUpdateOnDbOpen(boolValue);
 845       assertThat(opt.skipStatsUpdateOnDbOpen()).isEqualTo(boolValue);
 846     }
 847   }
 848
 849   @Test
 850   public void walRecoveryMode() {
 851     try (final Options opt = new Options()) {
 852       for (final WALRecoveryMode walRecoveryMode : WALRecoveryMode.values()) {
 853         opt.setWalRecoveryMode(walRecoveryMode);
 854         assertThat(opt.walRecoveryMode()).isEqualTo(walRecoveryMode);
 855       }
 856     }
 857   }
 858
 859   @Test
 860   public void allow2pc() {
 861     try (final Options opt = new Options()) {
 862       final boolean boolValue = rand.nextBoolean();
 863       opt.setAllow2pc(boolValue);
 864       assertThat(opt.allow2pc()).isEqualTo(boolValue);
 865     }
 866   }
 867
 868   @Test
 869   public void rowCache() {
 870     try (final Options opt = new Options()) {
 871       assertThat(opt.rowCache()).isNull();
 872
 873       try(final Cache lruCache = new LRUCache(1000)) {
 874         opt.setRowCache(lruCache);
 875         assertThat(opt.rowCache()).isEqualTo(lruCache);
 876       }
 877
 878       try(final Cache clockCache = new ClockCache(1000)) {
 879         opt.setRowCache(clockCache);
 880         assertThat(opt.rowCache()).isEqualTo(clockCache);
 881       }
 882     }
 883   }
 884
 885   @Test
 886   public void walFilter() {
 887     try (final Options opt = new Options()) {
 888       assertThat(opt.walFilter()).isNull();
 889
 890       try (final AbstractWalFilter walFilter = new AbstractWalFilter() {
 891         @Override
 892         public void columnFamilyLogNumberMap(
 893             final Map<Integer, Long> cfLognumber,
 894             final Map<String, Integer> cfNameId) {
 895           // no-op
 896         }
 897
 898         @Override
 899         public LogRecordFoundResult logRecordFound(final long logNumber,
 900             final String logFileName, final WriteBatch batch,
 901             final WriteBatch newBatch) {
 902           return new LogRecordFoundResult(
 903               WalProcessingOption.CONTINUE_PROCESSING, false);
 904         }
 905
 906         @Override
 907         public String name() {
 908           return "test-wal-filter";
 909         }
 910       }) {
 911         opt.setWalFilter(walFilter);
 912         assertThat(opt.walFilter()).isEqualTo(walFilter);
 913       }
 914     }
 915   }
 916
 917   @Test
 918   public void failIfOptionsFileError() {
 919     try (final Options opt = new Options()) {
 920       final boolean boolValue = rand.nextBoolean();
 921       opt.setFailIfOptionsFileError(boolValue);
 922       assertThat(opt.failIfOptionsFileError()).isEqualTo(boolValue);
 923     }
 924   }
 925
 926   @Test
 927   public void dumpMallocStats() {
 928     try (final Options opt = new Options()) {
 929       final boolean boolValue = rand.nextBoolean();
 930       opt.setDumpMallocStats(boolValue);
 931       assertThat(opt.dumpMallocStats()).isEqualTo(boolValue);
 932     }
 933   }
 934
 935   @Test
 936   public void avoidFlushDuringRecovery() {
 937     try (final Options opt = new Options()) {
 938       final boolean boolValue = rand.nextBoolean();
 939       opt.setAvoidFlushDuringRecovery(boolValue);
 940       assertThat(opt.avoidFlushDuringRecovery()).isEqualTo(boolValue);
 941     }
 942   }
 943
 944   @Test
 945   public void avoidFlushDuringShutdown() {
 946     try (final Options opt = new Options()) {
 947       final boolean boolValue = rand.nextBoolean();
 948       opt.setAvoidFlushDuringShutdown(boolValue);
 949       assertThat(opt.avoidFlushDuringShutdown()).isEqualTo(boolValue);
 950     }
 951   }
 952
 953
 954   @Test
 955   public void allowIngestBehind() {
 956     try (final Options opt = new Options()) {
 957       assertThat(opt.allowIngestBehind()).isFalse();
 958       opt.setAllowIngestBehind(true);
 959       assertThat(opt.allowIngestBehind()).isTrue();
 960     }
 961   }
 962
 963   @Test
 964   public void preserveDeletes() {
 965     try (final Options opt = new Options()) {
 966       assertThat(opt.preserveDeletes()).isFalse();
 967       opt.setPreserveDeletes(true);
 968       assertThat(opt.preserveDeletes()).isTrue();
 969     }
 970   }
 971
 972   @Test
 973   public void twoWriteQueues() {
 974     try (final Options opt = new Options()) {
 975       assertThat(opt.twoWriteQueues()).isFalse();
 976       opt.setTwoWriteQueues(true);
 977       assertThat(opt.twoWriteQueues()).isTrue();
 978     }
 979   }
 980
 981   @Test
 982   public void manualWalFlush() {
 983     try (final Options opt = new Options()) {
 984       assertThat(opt.manualWalFlush()).isFalse();
 985       opt.setManualWalFlush(true);
 986       assertThat(opt.manualWalFlush()).isTrue();
 987     }
 988   }
 989
 990   @Test
 991   public void atomicFlush() {
 992     try (final Options opt = new Options()) {
 993       assertThat(opt.atomicFlush()).isFalse();
 994       opt.setAtomicFlush(true);
 995       assertThat(opt.atomicFlush()).isTrue();
 996     }
 997   }
 998
 999   @Test
1000   public void env() {
1001     try (final Options options = new Options();
1002          final Env env = Env.getDefault()) {
1003       options.setEnv(env);
1004       assertThat(options.getEnv()).isSameAs(env);
1005     }
1006   }
1007
1008   @Test
1009   public void linkageOfPrepMethods() {
1010     try (final Options options = new Options()) {
1011       options.optimizeUniversalStyleCompaction();
1012       options.optimizeUniversalStyleCompaction(4000);
1013       options.optimizeLevelStyleCompaction();
1014       options.optimizeLevelStyleCompaction(3000);
1015       options.optimizeForPointLookup(10);
1016       options.optimizeForSmallDb();
1017       options.prepareForBulkLoad();
1018     }
1019   }
1020
1021   @Test
1022   public void compressionTypes() {
1023     try (final Options options = new Options()) {
1024       for (final CompressionType compressionType :
1025           CompressionType.values()) {
1026         options.setCompressionType(compressionType);
1027         assertThat(options.compressionType()).
1028             isEqualTo(compressionType);
1029         assertThat(CompressionType.valueOf("NO_COMPRESSION")).
1030             isEqualTo(CompressionType.NO_COMPRESSION);
1031       }
1032     }
1033   }
1034
1035   @Test
1036   public void compressionPerLevel() {
1037     try (final Options options = new Options()) {
1038       assertThat(options.compressionPerLevel()).isEmpty();
1039       List<CompressionType> compressionTypeList =
1040           new ArrayList<>();
1041       for (int i = 0; i < options.numLevels(); i++) {
1042         compressionTypeList.add(CompressionType.NO_COMPRESSION);
1043       }
1044       options.setCompressionPerLevel(compressionTypeList);
1045       compressionTypeList = options.compressionPerLevel();
1046       for (final CompressionType compressionType : compressionTypeList) {
1047         assertThat(compressionType).isEqualTo(
1048             CompressionType.NO_COMPRESSION);
1049       }
1050     }
1051   }
1052
1053   @Test
1054   public void differentCompressionsPerLevel() {
1055     try (final Options options = new Options()) {
1056       options.setNumLevels(3);
1057
1058       assertThat(options.compressionPerLevel()).isEmpty();
1059       List<CompressionType> compressionTypeList = new ArrayList<>();
1060
1061       compressionTypeList.add(CompressionType.BZLIB2_COMPRESSION);
1062       compressionTypeList.add(CompressionType.SNAPPY_COMPRESSION);
1063       compressionTypeList.add(CompressionType.LZ4_COMPRESSION);
1064
1065       options.setCompressionPerLevel(compressionTypeList);
1066       compressionTypeList = options.compressionPerLevel();
1067
1068       assertThat(compressionTypeList.size()).isEqualTo(3);
1069       assertThat(compressionTypeList).
1070           containsExactly(
1071               CompressionType.BZLIB2_COMPRESSION,
1072               CompressionType.SNAPPY_COMPRESSION,
1073               CompressionType.LZ4_COMPRESSION);
1074
1075     }
1076   }
1077
1078   @Test
1079   public void bottommostCompressionType() {
1080     try (final Options options = new Options()) {
1081       assertThat(options.bottommostCompressionType())
1082           .isEqualTo(CompressionType.DISABLE_COMPRESSION_OPTION);
1083
1084       for (final CompressionType compressionType : CompressionType.values()) {
1085         options.setBottommostCompressionType(compressionType);
1086         assertThat(options.bottommostCompressionType())
1087             .isEqualTo(compressionType);
1088       }
1089     }
1090   }
1091
1092   @Test
1093   public void bottommostCompressionOptions() {
1094     try (final Options options = new Options();
1095          final CompressionOptions bottommostCompressionOptions = new CompressionOptions()
1096              .setMaxDictBytes(123)) {
1097
1098       options.setBottommostCompressionOptions(bottommostCompressionOptions);
1099       assertThat(options.bottommostCompressionOptions())
1100           .isEqualTo(bottommostCompressionOptions);
1101       assertThat(options.bottommostCompressionOptions().maxDictBytes())
1102           .isEqualTo(123);
1103     }
1104   }
1105
1106   @Test
1107   public void compressionOptions() {
1108     try (final Options options = new Options();
1109          final CompressionOptions compressionOptions = new CompressionOptions()
1110              .setMaxDictBytes(123)) {
1111
1112       options.setCompressionOptions(compressionOptions);
1113       assertThat(options.compressionOptions())
1114           .isEqualTo(compressionOptions);
1115       assertThat(options.compressionOptions().maxDictBytes())
1116           .isEqualTo(123);
1117     }
1118   }
1119
1120   @Test
1121   public void compactionStyles() {
1122     try (final Options options = new Options()) {
1123       for (final CompactionStyle compactionStyle :
1124           CompactionStyle.values()) {
1125         options.setCompactionStyle(compactionStyle);
1126         assertThat(options.compactionStyle()).
1127             isEqualTo(compactionStyle);
1128         assertThat(CompactionStyle.valueOf("FIFO")).
1129             isEqualTo(CompactionStyle.FIFO);
1130       }
1131     }
1132   }
1133
1134   @Test
1135   public void maxTableFilesSizeFIFO() {
1136     try (final Options opt = new Options()) {
1137       long longValue = rand.nextLong();
1138       // Size has to be positive
1139       longValue = (longValue < 0) ? -longValue : longValue;
1140       longValue = (longValue == 0) ? longValue + 1 : longValue;
1141       opt.setMaxTableFilesSizeFIFO(longValue);
1142       assertThat(opt.maxTableFilesSizeFIFO()).
1143           isEqualTo(longValue);
1144     }
1145   }
1146
1147   @Test
1148   public void rateLimiter() {
1149     try (final Options options = new Options();
1150          final Options anotherOptions = new Options();
1151          final RateLimiter rateLimiter =
1152              new RateLimiter(1000, 100 * 1000, 1)) {
1153       options.setRateLimiter(rateLimiter);
1154       // Test with parameter initialization
1155       anotherOptions.setRateLimiter(
1156           new RateLimiter(1000));
1157     }
1158   }
1159
1160   @Test
1161   public void sstFileManager() throws RocksDBException {
1162     try (final Options options = new Options();
1163          final SstFileManager sstFileManager =
1164              new SstFileManager(Env.getDefault())) {
1165       options.setSstFileManager(sstFileManager);
1166     }
1167   }
1168
1169   @Test
1170   public void shouldSetTestPrefixExtractor() {
1171     try (final Options options = new Options()) {
1172       options.useFixedLengthPrefixExtractor(100);
1173       options.useFixedLengthPrefixExtractor(10);
1174     }
1175   }
1176
1177   @Test
1178   public void shouldSetTestCappedPrefixExtractor() {
1179     try (final Options options = new Options()) {
1180       options.useCappedPrefixExtractor(100);
1181       options.useCappedPrefixExtractor(10);
1182     }
1183   }
1184
1185   @Test
1186   public void shouldTestMemTableFactoryName()
1187       throws RocksDBException {
1188     try (final Options options = new Options()) {
1189       options.setMemTableConfig(new VectorMemTableConfig());
1190       assertThat(options.memTableFactoryName()).
1191           isEqualTo("VectorRepFactory");
1192       options.setMemTableConfig(
1193           new HashLinkedListMemTableConfig());
1194       assertThat(options.memTableFactoryName()).
1195           isEqualTo("HashLinkedListRepFactory");
1196     }
1197   }
1198
1199   @Test
1200   public void statistics() {
1201     try(final Options options = new Options()) {
1202       final Statistics statistics = options.statistics();
1203       assertThat(statistics).isNull();
1204     }
1205
1206     try(final Statistics statistics = new Statistics();
1207         final Options options = new Options().setStatistics(statistics);
1208         final Statistics stats = options.statistics()) {
1209       assertThat(stats).isNotNull();
1210     }
1211   }
1212
1213   @Test
1214   public void maxWriteBufferNumberToMaintain() {
1215     try (final Options options = new Options()) {
1216       int intValue = rand.nextInt();
1217       // Size has to be positive
1218       intValue = (intValue < 0) ? -intValue : intValue;
1219       intValue = (intValue == 0) ? intValue + 1 : intValue;
1220       options.setMaxWriteBufferNumberToMaintain(intValue);
1221       assertThat(options.maxWriteBufferNumberToMaintain()).
1222           isEqualTo(intValue);
1223     }
1224   }
1225
1226   @Test
1227   public void compactionPriorities() {
1228     try (final Options options = new Options()) {
1229       for (final CompactionPriority compactionPriority :
1230           CompactionPriority.values()) {
1231         options.setCompactionPriority(compactionPriority);
1232         assertThat(options.compactionPriority()).
1233             isEqualTo(compactionPriority);
1234       }
1235     }
1236   }
1237
1238   @Test
1239   public void reportBgIoStats() {
1240     try (final Options options = new Options()) {
1241       final boolean booleanValue = true;
1242       options.setReportBgIoStats(booleanValue);
1243       assertThat(options.reportBgIoStats()).
1244           isEqualTo(booleanValue);
1245     }
1246   }
1247
1248   @Test
1249   public void ttl() {
1250     try (final Options options = new Options()) {
1251       options.setTtl(1000 * 60);
1252       assertThat(options.ttl()).
1253           isEqualTo(1000 * 60);
1254     }
1255   }
1256
1257   @Test
1258   public void compactionOptionsUniversal() {
1259     try (final Options options = new Options();
1260          final CompactionOptionsUniversal optUni = new CompactionOptionsUniversal()
1261              .setCompressionSizePercent(7)) {
1262       options.setCompactionOptionsUniversal(optUni);
1263       assertThat(options.compactionOptionsUniversal()).
1264           isEqualTo(optUni);
1265       assertThat(options.compactionOptionsUniversal().compressionSizePercent())
1266           .isEqualTo(7);
1267     }
1268   }
1269
1270   @Test
1271   public void compactionOptionsFIFO() {
1272     try (final Options options = new Options();
1273          final CompactionOptionsFIFO optFifo = new CompactionOptionsFIFO()
1274              .setMaxTableFilesSize(2000)) {
1275       options.setCompactionOptionsFIFO(optFifo);
1276       assertThat(options.compactionOptionsFIFO()).
1277           isEqualTo(optFifo);
1278       assertThat(options.compactionOptionsFIFO().maxTableFilesSize())
1279           .isEqualTo(2000);
1280     }
1281   }
1282
1283   @Test
1284   public void forceConsistencyChecks() {
1285     try (final Options options = new Options()) {
1286       final boolean booleanValue = true;
1287       options.setForceConsistencyChecks(booleanValue);
1288       assertThat(options.forceConsistencyChecks()).
1289           isEqualTo(booleanValue);
1290     }
1291   }
1292
1293   @Test
1294   public void compactionFilter() {
1295     try(final Options options = new Options();
1296         final RemoveEmptyValueCompactionFilter cf = new RemoveEmptyValueCompactionFilter()) {
1297       options.setCompactionFilter(cf);
1298       assertThat(options.compactionFilter()).isEqualTo(cf);
1299     }
1300   }
1301
1302   @Test
1303   public void compactionFilterFactory() {
1304     try(final Options options = new Options();
1305         final RemoveEmptyValueCompactionFilterFactory cff = new RemoveEmptyValueCompactionFilterFactory()) {
1306       options.setCompactionFilterFactory(cff);
1307       assertThat(options.compactionFilterFactory()).isEqualTo(cff);
1308     }
1309   }
1310
1311 }