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

Lär dig grunderna i Java och dess nyckelfunktioner i denna kurs. Efter avslutad kurs kommer du att kunna lösa enkla algoritmiska uppgifter och få en tydlig förståelse för hur grundläggande konsolapplikationer i Java fungerar.

Upptäck de unika egenskaperna hos Java och förstå varför det är ett rekommenderat programmeringsspråk att lära sig. Skriv din första Java-kod och utforska hur man skriver ut text till konsolen.

Lär dig grunderna i programmering, fördjupa dig i primitiva datatyper och utforska operationer med dessa. Skriv kod som utför matematiska uppgifter och utvärderar villkor för smidig exekvering.

Utforska olika loopar såsom for, while och do-while, vilka är grundläggande i alla programmeringsspråk. Loopar möjliggör effektiv iteration över stora datamängder och sparar avsevärt med tid. Används ofta vid uppgifter som sortering, arbete med arrayer, samlingar och mer.

Lär dig att effektivt använda arrayer i Java-programmering genom att upptäcka hur data kan grupperas i arrayer och utforska vanliga metoder och egenskaper för att arbeta med dem. Tekniker för att manipulera och optimera arrayer i verkliga applikationer kommer också att behandlas.

Lär dig om sträng, en viktig datatyp i Java, och upptäck dess många inbyggda metoder och operationer. Utforska sträng och StringBuilder, förstå deras grundläggande metoder och hur strängar används effektivt i Java.

Utmaning: Primitiva Typer

Lösning

Utmaning: Primitiva Typer

Lösning