Fonte de dados PICT

Por favor, certifique-se de que você está familiarizado com a execução básica do TAEF e sabe como criar testes usando-o, antes de prosseguir com esta seção.

Antecedentes e Referências do PICT

PICT significa Pairwise Independent Combinatorial Testing (Teste combinatório independente de pares). O PICT permite que você especifique variações para cada um dos seus parâmetros separadamente. Por exemplo, se o teste de API depender de dois parâmetros: FileName e FileExtension, pode-se pensar nas possíveis variações a considerar para FileName e para FileExtension separadamente assim:

• Nome do arquivo: a, z12390, Realllyreallyreallylonglonglonglonglonglonglonglonglonglong, normallength
• FileExtension: txt, png, bat, doc, exe, bmp, wav

Agora, podes ver que uma expansão combinatória de força bruta do acima mencionado (4 X 7 = 28) poderia facilmente ultrapassar os limites à medida que pensas em mais variações para adicionar à lista. Em tais cenários de caso de teste, o PICT poderia agregar muito valor gerando um conjunto compacto de resultados de parâmetros para obter uma cobertura combinatória abrangente sobre os parâmetros de entrada.

Suporte PICT no TAEF

O TAEF oferece suporte integrado para testes baseados em PICT.

Para tirar proveito disso, escreva seu arquivo de modelo de entrada para pict.exe como faria normalmente. Consulte os arquivos *.txt na pasta de exemplos mencionada acima. Pode ser útil verificar se o PICT é executado como esperado no ficheiro de modelo, testando-o primeiro no prompt de comando da seguinte forma:

pict.exe <model file> [/e:<seed file>]

Pict.exe está, com o resto dos binários, disponível no compartilhamento da versão mais recente do TAEF.

Uma vez que você terminou de criar seu arquivo de modelo (e arquivo semente) para PICT e verificou-o contra pict.exe no prompt de comando, agora você pode marcar seus testes para informar ao TAEF que eles são testes orientados por PICT. Se você estiver familiarizado com os testes baseados em dados baseados em tabelas disponíveis no TAEF, você encontrará isso muito semelhante.

Código nativo:

1     class PictExample
2     {
3         TEST_CLASS(PictExample)
4
5         BEGIN_TEST_METHOD(SimpleTest)
6             TEST_METHOD_PROPERTY(L"DataSource", L"pict:PictExample.txt")
7         END_TEST_METHOD()
8
9         BEGIN_TEST_METHOD(TestWithSeed)
10            TEST_METHOD_PROPERTY(L"DataSource", L"pict:TestWithSeed.txt")
11            TEST_METHOD_PROPERTY(L"Pict:SeedingFile", L"TestWithSeed.sed")
12            TEST_METHOD_PROPERTY(L"Pict:Timeout", L"00:01:30")
13        END_TEST_METHOD()
14
15        BEGIN_TEST_METHOD(TestWithFunction)
16            TEST_METHOD_PROPERTY(L"DataSource", L"pict:TestWithFunction.txt")
17        END_TEST_METHOD()
18    };

Código gerenciado:

1     [TestClass]
2     public class CSharpPictExample
3     {
4         [TestMethod]
5         [DataSource("pict:ConstraintsTest.txt")]
6         [TestProperty("Pict:SeedingFile", "ConstraintsTest.seed")]
7         public void ConstraintsTest()
8         {
9             ...
10        }
11
12        [TestMethod]
13        [DataSource("pict:SumofSquareRoots.txt")]
14        public void SumOfSquareRoots()
15        {
16            ...
17        }
18
19        public TestContext TestContext
20        {
21            get { return m_testContext; }
22            set { m_testContext = value; }
23        }
24
25        private TestContext m_testContext;
26    }

Como mostrado nos exemplos acima, você precisa especificar o nome do arquivo de modelo como DataSource. Você deve prefixar o nome do arquivo de modelo com "pict:" e fornecê-lo como DataSource para seu método de teste. No caso do teste gerenciado, assim como com qualquer outro teste controlado por dados com TAEF, você deve fornecer métodos get e set da propriedade TestContext e ter uma instância privada do mesmo em sua classe.

Se você quiser passar opções de comando para PICT, você pode usar metadados para essa finalidade. Use a tabela a seguir para mapear as opções de comando do Pict.exe para metadados TAEF.

Qualquer um dos metadados acima pode ser definido no prompt de comando, na propriedade DataSource ou como metadados de teste, classe ou nível de módulo, com precedência nessa ordem. Para defini-lo no prompt de comando, use a sintaxe:

te.exe <test dll> /Pict:Order=3 /Pict:SeedingFile=test.seed

Para definir metadados na propriedade DataSource, acrescente o nome do arquivo de modelo com um caractere de ponto de interrogação (?) e, em seguida, um conjunto de nomes de metadados separados por ampersand = pares de valores de metadados. Ao usar esse método, o prefixo "Pict:" para nomes de metadados é opcional. Aqui está um exemplo:

TEST_METHOD_PROPERTY(L"DataSource", L"Pict:model.txt?Order=3&CaseSensitive=true&Random=true")

Nos bastidores, a TAEF fornecerá seu arquivo de modelo de entrada e opções de comando para o PICT e obterá os resultados. Se o PICT produzir erros ou avisos, você os verá registrados como avisos pelo TAEF. Para cada linha de saída resultante que o PICT produz, o TAEF invocará novamente o teste em questão.

Definir o valor "Pict:RandomSeed" alterará o padrão para "Pict:Random" de false para true. Desta forma, você pode definir explicitamente "Pict:Random" como false para fazer com que o TAEF ignore "Pict:RandomSeed".

O tempo limite padrão permitido para PICT.exe executar no arquivo modelo e na entrada do arquivo semente especificado é de 5 minutos. Se o ficheiro do modelo for mais complexo e precisar de mais de 5 minutos para que PICT.exe retorne os resultados, poderá substituir este limite de tempo, conforme mostrado no exemplo de CPP acima, especificando os metadados "Pict:Timeout". No exemplo, um tempo limite de 1,5 minutos é especificado através do formato padrão TAEF Time-out . Como os outros metadados PICT, os metadados "Pict:Timeout" são herdados e, portanto, podem ser especificados para toda a classe ou módulo.

Você pode acessar os valores de dados durante uma determinada invocação a partir do seu método de teste e seus métodos de configuração e limpeza associados da mesma forma que fez para testes controlados por dados baseados em tabela com TAEF - usando a classe TestData para código nativo e usando o TestContext para código gerenciado assim:

Código nativo:

1     void PictExample::SimpleTest()
2     {
3         String valueA;
4         if (SUCCEEDED(TestData::TryGetValue(L"A", valueA)))
5         {
6           Log::Comment(L"A retrieved was " + valueA);
7         }
8
9         String valueB;
10        if (SUCCEEDED(TestData::TryGetValue(L"B", valueB)))
11        {
12            Log::Comment(L"B retrieved was " + valueB);
13        }
14
15        String valueC;
16        if (SUCCEEDED(TestData::TryGetValue(L"C", valueC)))
17        {
18            Log::Comment(L"C retrieved was " + valueC);
19        }
20
21        unsigned int index;
22        if (SUCCEEDED(TestData::TryGetValue(L"index", index)))
23        {
24            Log::Comment(String().Format(L"At index %d", index));
25        }
26    }

Código gerenciado:

1      [TestClass]
2      public class CSharpPictExample
3      {
4          [TestMethod]
5          [DataSource("pict:ConstraintsTest.txt")]
6          public void ConstraintsTest()
7          {
8              Log.Comment("A is " + m_testContext.DataRow["A"]);
9              Log.Comment("B is " + m_testContext.DataRow["B"]);
10             Log.Comment("C is " + m_testContext.DataRow["C"]);
11             Log.Comment("D is " + m_testContext.DataRow["D"]);
12
13             UInt32 index = (UInt32)m_testContext.DataRow["Index"];
14             Log.Comment("At index " + index.ToString());
15        }
16
17        [TestMethod]
18        [DataSource("pict:SumofSquareRoots.txt")]
19        public void SumOfSquareRoots()
20        {
21             Log.Comment("A is " + m_testContext.DataRow["A"]);
22             Log.Comment("B is " + m_testContext.DataRow["B"]);
23
24             UInt32 index = (UInt32)m_testContext.DataRow["Index"];
25             Log.Comment("At index " + index.ToString());
26        }
27
28        public TestContext TestContext
29        {
30             get { return m_testContext; }
31             set { m_testContext = value; }
32        }
33
34        private TestContext m_testContext;
35    }

Assim como em qualquer teste controlado por dados no TAEF, "Índice" é reservado e não deve ser usado como nome de parâmetro. Índice refere-se implicitamente ao índice da invocação do método de teste e é acessível a partir do método de teste se o teste precisar dele.

Também é importante notar que, no caso de testes baseados em PICT, o tipo de dados para todos os parâmetros é assumido como WEX::Common::String (nativo), String(gerenciado) ou VT_BSTR(script). A conversão e interpretação é deixada ao critério do utilizador.

Agora que você terminou de criar o teste baseado em PICT usando o TAEF, você pode invocá-lo no prompt de comando e aplicar todos os recursos de comando que o TAEF oferece a ele: like /list para obter uma lista de todos os métodos de teste que serão gerados usando a saída PICT como dados, /listproperties para obter uma lista dos nomes dos métodos de teste juntamente com os metadados e valores de dados aos quais eles estão associados Etc. A principal coisa a observar antes de começar é garantir que pict.exe está no seu caminho.

Eis alguns exemplos:

te Examples\CPP.Pict.Example.dll /list /name:*SimpleTest*
Test Authoring and Execution Framework v2.9.3k for x86
        f:\ Examples\CPP.Pict.Example.dll
            WEX::TestExecution::Examples::PictExample
                WEX::TestExecution::Examples::PictExample::SimpleTest#0
                WEX::TestExecution::Examples::PictExample::SimpleTest#1
                WEX::TestExecution::Examples::PictExample::SimpleTest#2
                WEX::TestExecution::Examples::PictExample::SimpleTest#3
                WEX::TestExecution::Examples::PictExample::SimpleTest#4
                WEX::TestExecution::Examples::PictExample::SimpleTest#5
                WEX::TestExecution::Examples::PictExample::SimpleTest#6
                WEX::TestExecution::Examples::PictExample::SimpleTest#7
                WEX::TestExecution::Examples::PictExample::SimpleTest#8
                WEX::TestExecution::Examples::PictExample::SimpleTest#9
                WEX::TestExecution::Examples::PictExample::SimpleTest#10
                WEX::TestExecution::Examples::PictExample::SimpleTest#11
                WEX::TestExecution::Examples::PictExample::SimpleTest#12
                WEX::TestExecution::Examples::PictExample::SimpleTest#13
                WEX::TestExecution::Examples::PictExample::SimpleTest#14
                WEX::TestExecution::Examples::PictExample::SimpleTest#15
                WEX::TestExecution::Examples::PictExample::SimpleTest#16
                WEX::TestExecution::Examples::PictExample::SimpleTest#17
                WEX::TestExecution::Examples::PictExample::SimpleTest#18
                WEX::TestExecution::Examples::PictExample::SimpleTest#19
                WEX::TestExecution::Examples::PictExample::SimpleTest#20
                WEX::TestExecution::Examples::PictExample::SimpleTest#21
                WEX::TestExecution::Examples::PictExample::SimpleTest#22
                WEX::TestExecution::Examples::PictExample::SimpleTest#23

Para ler mais sobre os critérios de seleção (/select e /name), consulte a página wiki Seleção.

te Examples\Csharp.Pict.Example.dll /listproperties /select:"@Name='*SumofSquare*'
                    and @Data:index>10
Test Authoring and Execution Framework v2.9.3k for x86
        f:\ Examples\CSharp.Pict.Example.dll
            WEX.Examples.CSharpPictExample
                WEX.Examples.CSharpPictExample.SumOfSquareRoots#11
                        Property[DataSource] = pict:SumofSquareRoots.txt
                        Data[a] = 1
                        Data[b] = ~-1
                WEX.Examples.CSharpPictExample.SumOfSquareRoots#12
                        Property[DataSource] = pict:SumofSquareRoots.txt
                        Data[a] = 2
                        Data[b] = ~-1

O exemplo acima mostra como você pode selecionar usando o índice. Você também pode optar por selecionar com base no valor dos dados.

te Examples\Csharp.Pict.Example.dll /listproperties /select:"@Name='*SumofSquare*'
                    and (@Data:A='1' and @Data:B='1')"
Test Authoring and Execution Framework v2.9.3k for x86
        f:\ Examples\CSharp.Pict.Example.dll
            WEX.Examples.CSharpPictExample
                WEX.Examples.CSharpPictExample.SumOfSquareRoots#8
                        Property[DataSource] = pict:SumofSquareRoots.txt
                        Data[a] = 1
                        Data[b] = 1

Cache de resultados PICT

Alguns arquivos de modelo podem ficar muito complexos e podem exigir mais tempo para serem processados por Pict.exe. O TAEF tenta reduzir o tempo de processamento dos resultados armazenando em cache os resultados durante uma determinada execução de Te.exe. Se um teste subsequente na mesma execução referir-se à mesma combinação de modelo e ficheiro de seed, o TAEF usará os resultados armazenados em cache. Por padrão, no final de cada execução, os resultados armazenados em cache são excluídos.

Se quiser continuar a aproveitar os resultados armazenados em cache em execuções subsequentes, você pode especificar a opção "/persistPictResults" no prompt de comando durante a execução. Sempre que você especificar "/persistPictResults" para seu comando, a primeira execução realmente executará pict.exe e pode levar muito tempo, mas todas as execuções subsequentes usarão os resultados armazenados em cache nos casos em que o modelo e o arquivo seed não foram modificados. Nota: Você precisará continuar especificando "/persistPictResults" para execuções subsequentes. Qualquer execução subsequente em que você não especificá-la excluirá os resultados armazenados em cache no final dessa execução.

Se persistir os resultados do PICT e usar dados armazenados em cache for algo que você deseja fazer por padrão, você pode defini-lo como parte de sua variável de ambiente te_cmd, conforme mostrado abaixo, e eliminar a necessidade de especificá-lo em cada execução. Consulte Executando testes para obter mais detalhes sobre te_cmd.

set te_cmd = /persistPictResults

Os arquivos de resultado armazenados em cache são armazenados em uma pasta chamada "TAEF-PICT" no diretório %temp%, se Te.exe tiver acesso a ele, ou no diretório de execução atual de onde Te.exe foi iniciado. A única vez que você pode ter os resultados em um estado inconsistente é se você pressionar Ctrl + C durante a execução. Nesse caso, o TAEF tentará excluir os resultados armazenados em cache, mas se não for possível fazê-lo, verá um erro relacionado. O erro solicitará que você exclua o local dos resultados armazenados em cache. Não o fazer pode resultar num comportamento indefinido ou errado nos testes subsequentes.

Com o suporte PICT integrado no TAEF, agora você pode aproveitar ao máximo os recursos do PICT, bem como os recursos do TAEF em sua automação de teste.

DataSource como um recurso

Você pode adicionar modelos PICT e arquivos de propagação como recursos em seu módulo de teste.

No código nativo, isso é feito especificando o nome do recurso em vez do nome do arquivo nos metadados DataSource. Aqui está um exemplo:

BEGIN_TEST_METHOD(ResourceNameDataSource)
    TEST_METHOD_PROPERTY(L"DataSource", L"Pict:MyModelResourceName?SeedingFile=MySeedingResourceName")
END_TEST_METHOD()

"MyModelResourceName" e "MySeedingResourceName" são os nomes de recursos definidos em um arquivo .rc. O tipo de recurso precisa ser DATAFILE, ao contrário das fontes de dados de tabela , onde o tipo de recurso precisa ser DATASOURCE_XML.

MyModelResourceName DATAFILE "model.txt"
MySeedingResourceName DATAFILE "seed.txt"

O valor de metadados DataSource permanecerá o mesmo que quando o modelo era um arquivo. Da mesma forma, no código nativo, você pode fazer com que o nome do recurso seja o mesmo que o nome do arquivo. O TAEF procurará primeiro a presença do arquivo real com o nome DataSource. Se o arquivo não for encontrado, ele prossiga procurando nos recursos do módulo de teste. Como alterar o DataSource armazenado no recurso requer recompilação, você pode aproveitar esse design copiando o arquivo DataSource para o mesmo local que a dll de teste durante o desenvolvimento (e nomeando o nome do recurso para ser o mesmo que o nome do arquivo). Depois de concluir o teste, mova (não copie) o arquivo de volta para o diretório de código e recompile para incorporar o recurso.