Testes

@isTest
public class TestesTempConverter {

    @isTest static void testaCToF(){
        TempConverter tc = new TempConverter('cf',0);
        Map<String, List<Decimal>> mapa = tc.retornaTemp();
        System.debug(mapa);
        String chave;
        Decimal inputTemp, outputTemp;
        for(String key:mapa.keySet()){
            chave = key;
            inputTemp = mapa.get(key)[0];
            outputTemp = mapa.get(key)[1];
            System.debug(chave+' - '+inputTemp+' - '+outputTemp);
        }
        System.assertEquals('cf',chave);
        System.assertEquals(32, outputTemp);
        System.assertEquals(0, inputTemp);
    }
    @isTest static void testaFToC(){
        TempConverter tc = new TempConverter('fc',32);
        Map<String, List<Decimal>> mapa = tc.retornaTemp();
        System.debug(mapa);
        String chave;
        Decimal inputTemp, outputTemp;
        for(String key:mapa.keySet()){
            chave = key;
            inputTemp = mapa.get(key)[0];
            outputTemp = mapa.get(key)[1];
            System.debug(chave+' - '+inputTemp+' - '+outputTemp);
        }
        System.assertEquals('fc',chave);
        System.assertEquals(0, outputTemp);
        System.assertEquals(32, inputTemp);
    }

    @isTest static void testaKToC(){
        TempConverter tc = new TempConverter('kc',273.15);
        Map<String, List<Decimal>> mapa = tc.retornaTemp();
        System.debug(mapa);
        String chave;
        Decimal inputTemp, outputTemp;
        for(String key:mapa.keySet()){
            chave = key;
            inputTemp = mapa.get(key)[0];
            outputTemp = mapa.get(key)[1];
            System.debug(chave+' - '+inputTemp+' - '+outputTemp);
        }
        System.assertEquals('kc',chave);
        System.assertEquals(0, outputTemp);
        System.assertEquals(273.15, inputTemp);
    }

    @isTest static void testaKToF(){
        TempConverter tc = new TempConverter('kf',0);
        Map<String, List<Decimal>> mapa = tc.retornaTemp();
        System.debug(mapa);
        String chave;
        Decimal inputTemp, outputTemp;
        for(String key:mapa.keySet()){
            chave = key;
            inputTemp = mapa.get(key)[0];
            outputTemp = mapa.get(key)[1];
            System.debug(chave+' - '+inputTemp+' - '+outputTemp);
        }
        System.assertEquals('kf',chave);
        System.assertEquals(-459.67, outputTemp);
        System.assertEquals(0, inputTemp);
    }

    @isTest static void testaFToK(){
        TempConverter tc = new TempConverter('fk',32);
        Map<String, List<Decimal>> mapa = tc.retornaTemp();
        System.debug(mapa);
        String chave;
        Decimal inputTemp, outputTemp;
        for(String key:mapa.keySet()){
            chave = key;
            inputTemp = mapa.get(key)[0];
            outputTemp = mapa.get(key)[1];
            System.debug(chave+' - '+inputTemp+' - '+outputTemp);
        }
        System.assertEquals('fk',chave);
        System.assertEquals(273.15, outputTemp);
        System.assertEquals(32, inputTemp);
    }

    @isTest static void testaCToK(){
        TempConverter tc = new TempConverter('ck',-273.15);
        Map<String, List<Decimal>> mapa = tc.retornaTemp();
        System.debug(mapa);
        String chave;
        Decimal inputTemp, outputTemp;
        for(String key:mapa.keySet()){
            chave = key;
            inputTemp = mapa.get(key)[0];
            outputTemp = mapa.get(key)[1];
            System.debug(chave+' - '+inputTemp+' - '+outputTemp);
        }
        System.assertEquals('ck',chave);
        System.assertEquals(0, outputTemp);
        System.assertEquals(-273.15, inputTemp);
    }

    @isTest static void testaNaoExiste(){
        TempConverter tc = new TempConverter('zz',32);
        Map<String, List<Decimal>> mapa = tc.retornaTemp();
        System.debug(mapa);
        String chave;
        Decimal inputTemp, outputTemp;
        for(String key:mapa.keySet()){
            chave = key;
            inputTemp = mapa.get(key)[0];
            outputTemp = mapa.get(key)[1];
            System.debug(chave+' - '+inputTemp+' - '+outputTemp);
        }
        System.assertEquals('n/a',chave);
        System.assertEquals(0, outputTemp);
        System.assertEquals(0, inputTemp);
    }

    @isTest static void testaConstrutorVazio(){
        TempConverter tc = new TempConverter();

        System.assertEquals(null,tc.conversao, '');
        System.assertEquals(null, tc.resultado,'');
        System.assertEquals(null, tc.temperatura,'');
    }
}

public with sharing class TempConverter {
    //declaração do atributo que determina o tipo de conversão
    @TestVisible private String conversao;
    //declaração do atributo que corresponde à temperatura a ser convertida
    @TestVisible private Decimal temperatura;
    //declaração do atributo que conterá o valor do resultado de qq uma das conversões
    @TestVisible private Decimal resultado;
    //criação do construtor vazio em função da criação do construtor com parâmetros
    public TempConverter(){}
    //criação do construtor que recebe o tipo da conversão e a temperatura a ser convertida
    public TempConverter(String conversao, Decimal temperatura){
        //atribuição do tipo da conversão recebida pelo construtor para o atributo de instância
        this.conversao = conversao;
        //atribuição do valor da temperatura recebida pelo construtor para o atributo de instância
        this.temperatura = temperatura;
        //chamada do método que chama o método específico definido pelo tipo de conversão
        this.escolheConversao();
    }
    //método de faz a conversão de celsius para fahrenheit e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void CelsiusToFah(){
        this.resultado = (this.temperatura*9/5)+32;
    }
    //método de faz a conversão de fahrenheit para celsius e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void FahToCelsius(){
        this.resultado = (this.temperatura - 32)*5/9;
    }
    //método de faz a conversão de celsius para kelvin e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void CelsiusToKelvin(){
        this.resultado = this.temperatura + 273.15;
    }
    //método de faz a conversão de kelvin para celsius e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void KelvinToCelsius(){
        this.resultado = this.temperatura - 273.15;
    }
    //método de faz a conversão de fahrenheit para kelvin e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void FahToKelvin(){
        this.resultado = (this.temperatura - 32) * 5/9 + 273.15;
    }
    //método de faz a conversão de kelvin para fahrenheit e atribui o resultado ao atributo de
    //instância chamado resultado.
    private void KelvinToFah(){
        this.resultado = (this.temperatura - 273.15)*9/5 + 32;
    }
    //método que faz o chaveamento para determinação da execução do método específico de conversão
    //em função do tipo da conversão
    private void escolheConversao(){
        switch on this.conversao{
            when 'cf'{
                //chamada do método que converte de celsius para fahrenheit
                this.CelsiusToFah();
            }
            when 'fc'{
                //chamada do método que converte de fahrenheit para celsius
                this.FahToCelsius();
            }
            when 'ck'{
                //chamada do método que converte de celsius para kelvin
                this.CelsiusToKelvin();
            }
            when 'kc'{
                //chamada do método que converte de kelvin para celsius
                this.KelvinToCelsius();
            }
            when 'fk'{
                //chamada do método que converte de fahrenheit para kelvin
                this.FahToKelvin();
            }
            when 'kf'{
                //chamada do método que converte de kelvin para fahrenheit
                this.KelvinToFah();
            }
            when else{
                //esse when atribui 0 para o valor de temperatura do resultado e n/a
                //(não aplicável) em função de ter sido escolhida uma sigla que não
                //pertence ao conjunto das que devem ser admitidas para a conversão
                this.resultado = 0;
                this.conversao = 'n/a';
                this.temperatura = 0;
            }
        }
    }
    //método que retorna um map que contém uma chave que corresponde ao tipo de conversão e
    //um valor, que é uma lista de dois valores decimais, que correspondem respectivamente
    //nas posições de índice [0] e [1], da temperatura que será convertida e da temperatura
    //que já foi convertida
    public Map<String, List<Decimal>> retornaTemp(){
        //O código comentado abaixo é uma opção para se enviar como valor no map
        //que é retornado para quem chama esse método
        /*
        Objeto obj = new Objeto();
        obj.tempEntrada = this.temperatura;
        obj.tempSaida = this.resultado;
        */
        //criação do map que será retornado
        Map<String, List<Decimal>> mapa = new Map<String, List<Decimal>>();
        //populando o map com o tipo de conversão e a lista com os dois valores
        //correspondentes as temperaturas de entrada e saída
        mapa.put(this.conversao, new List<Decimal>{this.temperatura, this.resultado});
        return mapa;
    }
}

/* CÓDIGO DO ANONYMOUS
//atribuição do valor à ser convertido
Decimal tempParaConverter = 273.15;
//atribuição do tipo da conversão
String conversor = 'kc';
//declaração do texto correspondente aos tipos de temperaturas, da que será
//convertida e da que já foi convertida, respectivamente
String tempEntrada, tempSaida;
//criação do objeto e instância de classe, com a passagem das variáveis que contém
//os valores do tipo de conversão e da temperatura, respectivamente
TempConverter tc = new TempConverter(conversor, tempParaConverter);
//declaração do map que recebe a chave e valor pela execução do método de retorno
//do resultado, que pertence à classe, e atribuição do resultado ao objeto do tipo Map
//desses valores
Map<String, List<Decimal>> mapa = tc.retornaTemp();
//Exibição do map retornado por motivos didáticos
System.debug(mapa);
//declaração e inicialização da variável de maior escopo que conterá a chave do map, que corresponde
//ao tipo da conversão que será realizada, após a iteração das chaves do map (que conterá
//somente um único elemento)
String conversorRetornado = '';
//Iteração das chaves do map que foi retornado, e atribuição da chave para a variável declarada
//acima, para que seja acessada fora do escopo do loop
for(String key:mapa.keySet()){
    conversorRetornado = key;
}
//Declaração e atribuição de Lista, que contém os valores do map que recebeu o retorno com
//os resultados da operação
List<Decimal> listaRetornada = mapa.get(conversorRetornado);
//declaração e atribuição do conteúdo das duas posições da lista que recebeu as temperaturas
//de entrada para conversão e de saída que é o resultado da conversão
Decimal tempIn = listaRetornada[0];
Decimal tempOut = listaRetornada[1];
        //chaveamento para atribuição de string mais estética para apresentação de frase
        //com os tipos de temperaturas, de entrada e saída, correspondentes às temperaturas
        //sendo a primeira a ser convertida e a segunda já convertida
        switch on conversor{
            when 'cf'{
                tempEntrada = 'Celsius';
                tempSaida = 'Fahrenheit';
            }
            when 'fc'{
                tempEntrada = 'Fahrenheit';
                tempSaida = 'Celsius';
            }
            when 'ck'{
                tempEntrada = 'Celsius';
                tempSaida = 'Kelvin';
            }
            when 'kc'{
                tempEntrada = 'Kelvin';
                tempSaida = 'Celsius';
            }
            when 'fk'{
                tempEntrada = 'Fahrenheit';
                tempSaida = 'Kelvin';
            }
            when 'kf'{
                tempEntrada = 'Kelvin';
                tempSaida = 'Fahrenheit';
            }
        }
//Exibição da frase com o resultado final
System.debug(tempIn+'º '+tempEntrada+' equivale a '+tempOut+'º '+tempSaida);

*/