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

Learn the fundamentals of Java and its key features in this course. By the end, you'll be able to solve simple algorithmic tasks and gain a clear understanding of how basic console Java applications operate.

Discover the unique features of Java and understand why it's a recommended programming language to learn. Write your first Java code and explore how to print text to the console.

Learn the basics of programming, dive into primitive data types, and explore operations with them. Write code that performs mathematical tasks and evaluates conditions for seamless execution.

Explore various loops such as for, while, and do-while, which are essential in any programming language. Loops enable efficient iteration over large datasets, saving significant time. Apply them extensively in tasks like sorting, working with arrays, collections, and more.

Learn how to effectively use arrays in Java programming by discovering how to group data into arrays and exploring common methods and properties for working with them. Techniques for manipulating and optimizing arrays in real-world applications will also be examined.

Learn about String, a crucial data type in Java, and discover its many built-in methods and operations. Explore String and StringBuilder, understanding their basic methods and how to use strings effectively in Java.

Challenge: Primitive Types

Løsning

Challenge: Primitive Types

Løsning