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

Apprendi i fondamenti di Java e le sue caratteristiche principali in questo corso. Al termine, sarai in grado di risolvere semplici compiti algoritmici e avrai una comprensione chiara del funzionamento delle applicazioni Java di base su console.

Scopri le caratteristiche uniche di Java e comprendi perché è un linguaggio di programmazione consigliato da apprendere. Scrivi il tuo primo codice Java ed esplora come stampare testo sulla console.

Apprendere le basi della programmazione, approfondire i tipi di dati primitivi ed esplorare le operazioni con essi. Scrivere codice che esegue compiti matematici e valuta condizioni per un'esecuzione senza interruzioni.

Esplora diversi tipi di cicli come for, while e do-while, fondamentali in qualsiasi linguaggio di programmazione. I cicli consentono un'iterazione efficiente su grandi insiemi di dati, risparmiando tempo prezioso. Applicali ampiamente in attività come l'ordinamento, la gestione di array, collezioni e altro ancora.

Scopri come utilizzare efficacemente gli array nella programmazione Java imparando a raggruppare i dati in array ed esplorando i metodi e le proprietà comuni per lavorare con essi. Verranno inoltre esaminate tecniche per manipolare e ottimizzare gli array in applicazioni reali.

Scopri la stringa, un tipo di dato fondamentale in Java, e le sue numerose funzioni e operazioni integrate. Esplora String e StringBuilder, comprendendo i loro metodi di base e come utilizzare efficacemente le stringhe in Java.

Sfida: Tipi Primitivi

Soluzione

Sfida: Tipi Primitivi

Soluzione