package com.example;

import com.github.javaparser.StaticJavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.VariableDeclarator;

import org.junit.jupiter.api.*;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.PrintStream;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Stream;

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

public class MainTest {

    private static CompilationUnit cu;

    @BeforeAll
    public static void setup() throws Exception {
        File file = new File("src/main/java/com/example/Main.java");
        cu = StaticJavaParser.parse(file);
    }

    private String getVariableType(String varName) {
        return cu.findAll(VariableDeclarator.class).stream()
                .filter(v -> v.getNameAsString().equals(varName))
                .findFirst()
                .map(VariableDeclarator::getTypeAsString)
                .orElse(null);
    }

    record VarCheck(String name, List<String> allowedTypes) {}

    @TestFactory
    Stream<DynamicTest> dynamicTypeTests() {
        List<VarCheck> checks = List.of(
                new VarCheck("myNum", List.of("byte", "short", "int", "long")),
                new VarCheck("myFractional", List.of("double")),
                new VarCheck("myBiggerNum", List.of("byte", "short", "int", "long")),
                new VarCheck("myLetter", List.of("char")),
                new VarCheck("myBool", List.of("boolean")),
                new VarCheck("myWho", List.of("float"))
        );

        return checks.stream().map(check -> {
            String actualType = getVariableType(check.name());
            boolean valid = actualType != null && check.allowedTypes().contains(actualType);

            String displayName = valid
                    ? check.name() + " variable has valid type (" + String.join("/", check.allowedTypes()) + ")"
                    : "Expected " + check.name() + " variable to have type: " + String.join("/", check.allowedTypes());

            return dynamicTest(displayName, () -> {
                assertNotNull(actualType, "Variable '" + check.name() + "' not found");
                assertTrue(check.allowedTypes().contains(actualType),
                        "Found: " + actualType);
            });
        });
    }
    
    @Test
    @DisplayName("The code prints the right message")
    void testPrintsHelloWorldFlexible() {
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        PrintStream originalOut = System.out;
        System.setOut(new PrintStream(outContent));

        Main.main(new String[]{});

        System.setOut(originalOut);

        String output = outContent.toString().trim();

        Pattern pattern = Pattern.compile("It's\\\s+working\\\s*,\\\s*well\\\s+done\\\s*!?", Pattern.CASE_INSENSITIVE);
        assertTrue(pattern.matcher(output).find(), "Actual output: " + output);
    }
}

MainTest.java

A streamlined beginner course focused on the essential Java programming concepts: syntax, variables, data types, control flow, loops, arrays, and strings. This course omits backend-specific and recap content to provide a clear, hands-on introduction to Java's core features.

Challenge: Primitive Types

Рішення

Challenge: Primitive Types

Рішення