Add OpNop, OpUndef tests for spvTextToBinary

Add text_fixture::TextToBinaryTestBase::CompiledInstructions,
to more easily just examine the generated instructions by skipping
over the header.

Add spvtest::MakeInstruction utility function to easily generate
a vector containing an opcode and its operands.

CMakeLists.txt

@@ -184,6 +184,7 @@ if (NOT ${SPIRV_SKIP_EXECUTABLES})
       ${CMAKE_CURRENT_SOURCE_DIR}/test/TextLiteral.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/TextStartsNewInst.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/TextToBinary.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/test/TextToBinary.Miscellaneous.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/TextWordGet.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/Validate.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/ValidateID.cpp

test/TestFixture.h

@@ -122,6 +122,19 @@ class TextToBinaryTestBase : public T {
     return decoded_string;
   }
 
+  // Compiles SPIR-V text, asserts success, and returns the words representing
+  // the instructions.  In particular, skip the words in the SPIR-V header.
+  SpirvVector CompiledInstructions(const std::string& text) {
+    const SpirvVector code = CompileSuccessfully(text);
+    SpirvVector result;
+    // Extract just the instructions.
+    // If the code fails to compile, then return the empty vector.
+    // In any case, don't crash or invoke undefined behaviour.
+    if (code.size() >= kFirstInstruction)
+      result = Subvector(code, kFirstInstruction);
+    return result;
+  }
+
   void SetText(const std::string& code) {
     textString = code;
     text.str = textString.c_str();

test/TextToBinary.Miscellaneous.cpp

@@ -0,0 +1,55 @@
+// Copyright (c) 2015 The Khronos Group Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+// Assembler tests for instructions in the "Miscellaneous" section of the
+// SPIR-V spec.
+
+#include "UnitSPIRV.h"
+
+#include "gmock/gmock.h"
+#include "TestFixture.h"
+
+namespace {
+
+using SpirvVector = test_fixture::TextToBinaryTest::SpirvVector;
+using spv::Op;
+using spvtest::MakeInstruction;
+using ::testing::Eq;
+using TextToBinaryMisc = test_fixture::TextToBinaryTest;
+
+TEST_F(TextToBinaryMisc, OpNop) {
+  EXPECT_THAT(CompiledInstructions("OpNop"), Eq(MakeInstruction(OpNop, {})));
+}
+
+TEST_F(TextToBinaryMisc, OpUndef) {
+  const SpirvVector code = CompiledInstructions(R"(%f32 = OpTypeFloat 32
+                                                   %u = OpUndef %f32)");
+  const uint32_t typeID = 1;
+  EXPECT_THAT(code[1], Eq(typeID));
+  EXPECT_THAT(Subvector(code, 3), Eq(MakeInstruction(OpUndef, {typeID, 2})));
+}
+
+}  // anonymous namespace

test/UnitSPIRV.h

@@ -106,6 +106,16 @@ inline void PrintTo(const WordVector& words, ::std::ostream* os) {
   *os << std::endl;
 }
 
+// Returns a vector of words representing a single instruction with the
+// given opcode and number of operand words.
+inline std::vector<uint32_t> MakeInstruction(
+    spv::Op opcode, std::initializer_list<uint32_t> args) {
+  std::vector<uint32_t> result{
+      spvOpcodeMake(uint16_t(args.size() + 1), opcode)};
+  result.insert(result.end(), args.begin(), args.end());
+  return result;
+}
+
 } // namespace spvtest
 
 // A type for easily creating spv_text_t values, with an implicit conversion to