Skip to content

Checkstyle in Test, too. #127

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
felipestanzani merged 4 commits into from
May 22, 2026
Merged

Checkstyle in Test, too. #127

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
bbb0ea5
remove checkstyle warnings in test
jenspapenhagen May 21, 2026
39cdaf2
remove checkstyle warnings in test
jenspapenhagen May 22, 2026
317b15b
remove checkstyle warnings in test
jenspapenhagen May 22, 2026
531dd6d
fix pmd in test
jenspapenhagen May 22, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion build.gradle
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -122,7 +122,7 @@ tasks.checkstyleMain {
}

tasks.checkstyleTest {
enabled = false
enabled = true
ignoreFailures = true
}

Expand Down
10 changes: 10 additions & 0 deletions src/test/java/dev/toonformat/jtoon/BenchmarkConstants.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,10 @@
package dev.toonformat.jtoon;

final class BenchmarkConstants {

static final int WARMUP_ITERATIONS = 3;
static final int MEASUREMENT_ITERATIONS = 5;

private BenchmarkConstants() {
}
}
116 changes: 77 additions & 39 deletions src/test/java/dev/toonformat/jtoon/DecodeOptionsTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,18 +1,21 @@
package dev.toonformat.jtoon;

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
* Unit tests for DecodeOptions configuration record.
*/
@Tag("unit")
public class DecodeOptionsTest {

private static final int CUSTOM_INDENT = 4;
private static final int DEFAULT_MAX_DEPTH = 512;
private static final int DEFAULT_MAX_ARRAY_STRING_SIZE = 10_000_000;

@Nested
@DisplayName("Default Options")
class DefaultOptions {
Expand All @@ -21,7 +24,7 @@ class DefaultOptions {
@DisplayName("should have correct default values")
void testDefaultValues() {
// Given
DecodeOptions options = DecodeOptions.DEFAULT;
final DecodeOptions options = DecodeOptions.DEFAULT;

// Then
assertEquals(2, options.indent());
Expand All @@ -33,7 +36,7 @@ void testDefaultValues() {
@DisplayName("should create options with no-arg constructor")
void testNoArgConstructor() {
// Given
DecodeOptions options = new DecodeOptions();
final DecodeOptions options = new DecodeOptions();

// Then
assertEquals(2, options.indent());
Expand All @@ -50,19 +53,17 @@ class FactoryMethods {
@DisplayName("withIndent should create options with custom indent")
void testWithIndent() {
// Given
DecodeOptions options = DecodeOptions.withIndent(4);
final DecodeOptions options = DecodeOptions.withIndent(4);

// Then
assertEquals(4, options.indent());
assertEquals(Delimiter.COMMA, options.delimiter());
assertTrue(options.strict());
assertEquals(CUSTOM_INDENT, options.indent());
}

@Test
@DisplayName("withDelimiter should create options with custom delimiter")
void testWithDelimiter() {
// Given
DecodeOptions options = DecodeOptions.withDelimiter(Delimiter.PIPE);
final DecodeOptions options = DecodeOptions.withDelimiter(Delimiter.PIPE);

// Then
assertEquals(2, options.indent());
Expand All @@ -74,7 +75,7 @@ void testWithDelimiter() {
@DisplayName("withStrict should create options with custom strict mode")
void testWithStrict() {
// Given
DecodeOptions options = DecodeOptions.withStrict(false);
final DecodeOptions options = DecodeOptions.withStrict(false);

// Then
assertEquals(2, options.indent());
Expand All @@ -91,85 +92,95 @@ class SecurityLimits {
@DisplayName("should have default max depth of 512")
void testDefaultMaxDepth() {
// Given
DecodeOptions options = DecodeOptions.DEFAULT;
final DecodeOptions options = DecodeOptions.DEFAULT;

// Then
assertEquals(512, options.maxDepth());
assertEquals(DEFAULT_MAX_DEPTH, options.maxDepth());
}

@Test
@DisplayName("should have default max array size of 10,000,000")
void testDefaultMaxArraySize() {
// Given
DecodeOptions options = DecodeOptions.DEFAULT;
final DecodeOptions options = DecodeOptions.DEFAULT;

// Then
assertEquals(10_000_000, options.maxArraySize());
assertEquals(DEFAULT_MAX_ARRAY_STRING_SIZE, options.maxArraySize());
}

@Test
@DisplayName("should have default max string length of 10,000,000")
void testDefaultMaxStringLength() {
// Given
DecodeOptions options = DecodeOptions.DEFAULT;
final DecodeOptions options = DecodeOptions.DEFAULT;

// Then
assertEquals(10_000_000, options.maxStringLength());
assertEquals(DEFAULT_MAX_ARRAY_STRING_SIZE, options.maxStringLength());
}

@Test
@DisplayName("should reject maxDepth of 0")
void testMaxDepthZero() {
assertThrows(IllegalArgumentException.class,
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, 0, 10_000_000, 10_000_000));
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, 0,
DEFAULT_MAX_ARRAY_STRING_SIZE, DEFAULT_MAX_ARRAY_STRING_SIZE));
}

@Test
@DisplayName("should reject negative maxDepth")
void testMaxDepthNegative() {
assertThrows(IllegalArgumentException.class,
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, -1, 10_000_000, 10_000_000));
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, -1,
DEFAULT_MAX_ARRAY_STRING_SIZE, DEFAULT_MAX_ARRAY_STRING_SIZE));
}

@Test
@DisplayName("should reject maxDepth exceeding MAX_ALLOWED_DEPTH")
void testMaxDepthExceedsLimit() {
final int exceededDepth = 513;
assertThrows(IllegalArgumentException.class,
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, 513, 10_000_000, 10_000_000));
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, exceededDepth,
DEFAULT_MAX_ARRAY_STRING_SIZE, DEFAULT_MAX_ARRAY_STRING_SIZE));
}

@Test
@DisplayName("should accept boundary maxDepth of 512")
void testMaxDepthBoundary() {
assertDoesNotThrow(() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, 512, 10_000_000, 10_000_000));
assertDoesNotThrow(() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF,
DEFAULT_MAX_DEPTH, DEFAULT_MAX_ARRAY_STRING_SIZE,
DEFAULT_MAX_ARRAY_STRING_SIZE));
}

@Test
@DisplayName("should reject maxArraySize of 0")
void testMaxArraySizeZero() {
assertThrows(IllegalArgumentException.class,
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, 512, 0, 10_000_000));
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, DEFAULT_MAX_DEPTH,
0, DEFAULT_MAX_ARRAY_STRING_SIZE));
}

@Test
@DisplayName("should reject negative maxArraySize")
void testMaxArraySizeNegative() {
assertThrows(IllegalArgumentException.class,
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, 512, -1, 10_000_000));
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, DEFAULT_MAX_DEPTH,
-1, DEFAULT_MAX_ARRAY_STRING_SIZE));
}

@Test
@DisplayName("should reject maxStringLength of 0")
void testMaxStringLengthZero() {
assertThrows(IllegalArgumentException.class,
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, 512, 10_000_000, 0));
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, DEFAULT_MAX_DEPTH,
DEFAULT_MAX_ARRAY_STRING_SIZE, 0));
}

@Test
@DisplayName("should reject negative maxStringLength")
void testMaxStringLengthNegative() {
assertThrows(IllegalArgumentException.class,
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, 512, 10_000_000, -1));
() -> new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, DEFAULT_MAX_DEPTH,
DEFAULT_MAX_ARRAY_STRING_SIZE, -1));
}
}

Expand All @@ -181,10 +192,12 @@ class CustomOptions {
@DisplayName("should create options with all custom values")
void testAllCustomValues() {
// Given
DecodeOptions options = new DecodeOptions(4, Delimiter.TAB, false, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
final DecodeOptions options = new DecodeOptions(CUSTOM_INDENT, Delimiter.TAB, false,
PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH,
DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);

// Then
assertEquals(4, options.indent());
assertEquals(CUSTOM_INDENT, options.indent());
assertEquals(Delimiter.TAB, options.delimiter());
assertFalse(options.strict());
}
Expand All @@ -193,9 +206,18 @@ void testAllCustomValues() {
@DisplayName("should support all delimiter types")
void testAllDelimiters() {
// Then
assertEquals(Delimiter.COMMA, new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH).delimiter());
assertEquals(Delimiter.TAB, new DecodeOptions(2, Delimiter.TAB, true, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH).delimiter());
assertEquals(Delimiter.PIPE, new DecodeOptions(2, Delimiter.PIPE, true, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH).delimiter());
final DecodeOptions commaOpts = new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
assertEquals(Delimiter.COMMA, commaOpts.delimiter());
final DecodeOptions tabOpts = new DecodeOptions(2, Delimiter.TAB, true, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
assertEquals(Delimiter.TAB, tabOpts.delimiter());
final DecodeOptions pipeOpts = new DecodeOptions(2, Delimiter.PIPE, true, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
assertEquals(Delimiter.PIPE, pipeOpts.delimiter());
}
}

Expand All @@ -207,8 +229,12 @@ class RecordBehavior {
@DisplayName("should be equal when values are equal")
void testEquality() {
// Given
DecodeOptions options1 = new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
DecodeOptions options2 = new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
final DecodeOptions options1 = new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
final DecodeOptions options2 = new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);

// Then
assertEquals(options1, options2);
Expand All @@ -219,10 +245,18 @@ void testEquality() {
@DisplayName("should not be equal when values differ")
void testInequality() {
// Given
DecodeOptions options1 = new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
DecodeOptions options2 = new DecodeOptions(4, Delimiter.COMMA, true, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
DecodeOptions options3 = new DecodeOptions(2, Delimiter.PIPE, true, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
DecodeOptions options4 = new DecodeOptions(2, Delimiter.COMMA, false, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
final DecodeOptions options1 = new DecodeOptions(2, Delimiter.COMMA, true, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
final DecodeOptions options2 = new DecodeOptions(4, Delimiter.COMMA, true, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
final DecodeOptions options3 = new DecodeOptions(2, Delimiter.PIPE, true, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
final DecodeOptions options4 = new DecodeOptions(2, Delimiter.COMMA, false, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);

// Then
assertNotEquals(options1, options2);
Expand All @@ -234,15 +268,19 @@ void testInequality() {
@DisplayName("should have meaningful toString")
void testToString() {
// Given
DecodeOptions options = new DecodeOptions(4, Delimiter.TAB, false, PathExpansion.OFF, DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE, DecodeOptions.DEFAULT_MAX_STRING_LENGTH);
final DecodeOptions options = new DecodeOptions(4, Delimiter.TAB, false, PathExpansion.OFF,
DecodeOptions.MAX_ALLOWED_DEPTH, DecodeOptions.DEFAULT_MAX_ARRAY_SIZE,
DecodeOptions.DEFAULT_MAX_STRING_LENGTH);

// When
String str = options.toString();
final String str = options.toString();

// Then
assertTrue(str.contains("4"), "ToString should contain indent value: " + str);
assertTrue(str.contains("TAB") || str.contains("delimiter="), "ToString should contain delimiter: " + str);
assertTrue(str.contains("false") || str.contains("strict="), "ToString should contain strict value: " + str);
assertTrue(str.contains("TAB") || str.contains("delimiter="),
"ToString should contain delimiter: " + str);
assertTrue(str.contains("false") || str.contains("strict="),
"ToString should contain strict value: " + str);
}
}
}
Loading
Loading