Fonte de dados PICT

Artigo
06/15/2023

Verifique se você está familiarizado com a execução básica do TAEF e saiba como criar testes usando-o antes de prosseguir com esta seção.

Referências e planos de fundo PICT

PICT significa Teste Combinatório Independente Par a Par. PICT permite que você especifique variações para cada um de seus parâmetros separadamente. Por exemplo, se o teste de API depender de dois parâmetros: FileName e FileExtension, você poderá pensar nas possíveis variações a serem passadas para FileName e para FileExtensions separadamente da seguinte maneira:

FileName: a, z12390, Realllyreallyreallylonglonglonglonglong, normallength
FileExtension: txt, png, bat, doc, exe, bmp, wav

Agora, você pode ver que uma expansão combinatória de força bruta do acima (4 X 7 = 28) poderia facilmente sair dos limites conforme você pensa em mais variações para adicionar à lista. Nesses cenários de caso de teste, o PICT pode adicionar muito valor gerando um conjunto compacto de resultados de parâmetros para obter cobertura combinatória abrangente sobre os parâmetros de entrada.

Suporte a PICT no TAEF

O TAEF oferece suporte interno para testes baseados em PICT.

Para aproveitar isso, escreva seu arquivo de modelo de entrada para pict.exe como você faria normalmente. Consulte os arquivos *.txt na pasta de exemplos mencionada acima. Pode ser útil tentar se PICT for executado conforme o esperado no arquivo de modelo, experimentando-o no prompt de comando primeiro da seguinte maneira:

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

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

Um que você terminou de criar seu arquivo de modelo (e arquivo de semente) para PICT e verificou-o em relação a pict.exe no prompt de comando, agora você pode marcar seus testes para que o TAEF saiba que eles são testes controlados por PICT. Se você estiver familiarizado com os testes baseados em dados baseados em tabela disponíveis no TAEF, você achará 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    }

Conforme 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 fornecer isso como o DataSource para o método de teste. No caso do teste gerenciado, assim como acontece com qualquer outro teste controlado por dados com TAEF, você deve fornecer métodos de obtenção e definição da propriedade TestContext e ter uma instância privada da mesma em sua classe.

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

sintaxe de comando pict.exe	Sintaxe de metadados TAEF nativa	Sintaxe de metadados TAEF gerenciada
/o:3	TEST_METHOD_PROPERTY(L"Pict:Order", L"3")	[TestProperty("Pict:Order", "3")]
/D:	TEST_METHOD_PROPERTY(L"Pict:ValueSeparator", L",")	[TestProperty("Pict:ValueSeparator", ",")]
/a:		TEST_METHOD_PROPERTY(L"Pict:AliasSeparator", L"
/N:~	TEST_METHOD_PROPERTY(L"Pict:NegativeValuePrefix", L"~")	[TestProperty("Pict:NegativeValuePrefix", "~")]
/e:test.seed	TEST_METHOD_PROPERTY(L"Pict:SeedingFile", L"test.seed")	[TestProperty("Pict:SeedingFile", "test.seed")]
/r	TEST_METHOD_PROPERTY(L"Pict:Random", L"true")	[TestProperty("Pict:Random", "true")]
/r:33	TEST_METHOD_PROPERTY(L"Pict:RandomSeed", L"33")	[TestProperty("Pict:RandomSeed", "33")]
/c	TEST_METHOD_PROPERTY(L"Pict:CaseSensitive", L"true")	[TestProperty("Pict:CaseSensitive", "true")]

Qualquer um dos metadados acima pode ser definido no prompt de comando, na propriedade DataSource ou como metadados de nível de teste, classe ou 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 um conjunto de pares de valores de metadados separados por e comercial = pares de valores de metadados. Ao usar esse método, o prefixo "Pict:" para nomes de metadados é opcional. Veja um exemplo:

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

Nos bastidores, o TAEF fornecerá o arquivo de modelo de entrada e as opções de comando para PICT e obterá os resultados. Se 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. Dessa forma, você pode definir explicitamente "Pict:Random" como false para que o TAEF ignore "Pict:RandomSeed".

O tempo limite padrão permitido para PICT.exe executar no arquivo de modelo e na entrada de arquivo de semente especificada é de 5 minutos. Se o arquivo de modelo estiver mais envolvido e precisar de mais de 5 minutos para PICT.exe retornar resultados, você poderá substituir esse tempo limite conforme mostrado no exemplo do CPP acima especificando os metadados "Pict:Timeout ". No exemplo, um tempo limite de 1,5 minuto é especificado por meio do formato de tempo limite taef padrão. Assim 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 de seu método de teste e seus métodos de instalação e limpeza associados da mesma maneira que você fez para testes baseados em dados baseados em tabela com TAEF – usando a classe TestData para código nativo e usando o TestContext para código gerenciado como 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 acontece com todos os testes controlados por dados no TAEF, "Index" é reservado e não deve ser usado como nome do parâmetro. Index 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 observar que, no caso de testes baseados em PICT, o tipo de dados para todos os parâmetros é considerado WEX::Common::String (nativo), String(gerenciado) ou VT_BSTR(script). A conversão e a interpretação são deixadas para o usuário.

Agora que você terminou de criar o teste baseado em PICT usando TAEF, você pode invocá-lo no prompt de comando e aplicar todos os recursos de comando que o TAEF oferece a ele: como /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 de método de teste junto com os metadados e valores de dados aos quais eles estão associados Etc. O principal a observar antes de começar é garantir que pict.exe esteja em seu caminho.

Veja 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 critérios de seleção (/select e /name), consulte a página Wiki de 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 de 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 de execução se referir à mesma combinação de arquivo de semente e modelo, 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 você quiser continuar a aproveitar os resultados armazenados em cache nas execuções subsequentes, poderá 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 será realmente executada 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 de semente não foram modificados. Observação: 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ê poderá defini-lo como parte de sua variável de ambiente te_cmd conforme mostrado abaixo e eliminar a necessidade de especificá-los 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ê atingir Ctrl + C durante a execução. Nesse caso, o TAEF tentará excluir os resultados armazenados em cache, mas se não for possível fazer isso, você verá um erro no efeito. O erro solicitará que você exclua o local de resultados armazenados em cache. Falha ao fazer pode resultar em comportamento indefinido ou incorreto em testes subsequentes.

Com o suporte pict interno no TAEF, agora você pode aproveitar ao máximo os recursos no PICT, bem como os recursos no 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 do DataSource. Veja 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 recurso definidos em um arquivo .rc. O tipo de recurso precisa ser DATAFILE, ao contrário das fontes de dados de tabela em que o tipo de recurso precisa ser DATASOURCE_XML.

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

O valor de metadados do DataSource permanecerá o mesmo de 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 primeiro procurará a presença do arquivo real com o nome datasource. Se o arquivo não for encontrado, ele continuará examinando os 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 como 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 inserir o recurso.

Partilhar via

Fonte de dados PICT

Referências e planos de fundo PICT

Suporte a PICT no TAEF

Cache de resultados PICT

DataSource como um recurso

Comentários

Recursos adicionais