thrift 0.22.0 → 0.23.0

data/spec/thin_http_server_spec.rb

@@ -22,13 +22,10 @@ require 'rack/test'
 require 'thrift/server/thin_http_server'
 
 describe Thrift::ThinHTTPServer do
-
   let(:processor) { double('processor') }
 
   describe "#initialize" do
-
     context "when using the defaults" do
-
       it "binds to port 80, with host 0.0.0.0, a path of '/'" do
         expect(Thin::Server).to receive(:new).with('0.0.0.0', 80, an_instance_of(Rack::Builder))
         Thrift::ThinHTTPServer.new(processor)
@@ -43,11 +40,9 @@ describe Thrift::ThinHTTPServer do
         expect(Thrift::BinaryProtocolFactory).to receive(:new)
         Thrift::ThinHTTPServer.new(processor)
       end
-
     end
 
     context "when using the options" do
-
       it 'accepts :ip, :port, :path' do
         ip = "192.168.0.1"
         port = 3000
@@ -64,13 +59,10 @@ describe Thrift::ThinHTTPServer do
         Thrift::ThinHTTPServer.new(processor,
                            :protocol_factory => Thrift::JsonProtocolFactory.new)
       end
-
     end
-
   end
 
   describe "#serve" do
-
     it 'starts the Thin server' do
       underlying_thin_server = double('thin server', :start => true)
       allow(Thin::Server).to receive(:new).and_return(underlying_thin_server)
@@ -81,7 +73,6 @@ describe Thrift::ThinHTTPServer do
       thin_thrift_server.serve
     end
   end
-
 end
 
 describe Thrift::ThinHTTPServer::RackApplication do
@@ -95,23 +86,20 @@ describe Thrift::ThinHTTPServer::RackApplication do
   end
 
   context "404 response" do
-
     it 'receives a non-POST' do
       header('Content-Type', "application/x-thrift")
       get "/"
-      expect(last_response.status).to be 404
+      expect(last_response.status).to eq 404
     end
 
     it 'receives a header other than application/x-thrift' do
       header('Content-Type', "application/json")
       post "/"
-      expect(last_response.status).to be 404
+      expect(last_response.status).to eq 404
     end
-
   end
 
   context "200 response" do
-
     before do
       allow(protocol_factory).to receive(:get_protocol)
       allow(processor).to receive(:process)
@@ -132,10 +120,7 @@ describe Thrift::ThinHTTPServer::RackApplication do
     it 'status code 200' do
       header('Content-Type', "application/x-thrift")
       post "/"
-      expect(last_response.ok?).to be_truthy
+      expect(last_response.ok?).to be true
     end
-
   end
-
 end
-

data/spec/types_spec.rb

@@ -20,7 +20,6 @@
 require 'spec_helper'
 
 describe Thrift::Types do
-
   before(:each) do
     Thrift.type_checking = true
   end
@@ -39,33 +38,33 @@ describe Thrift::Types do
 
     it "should check types properly" do
       # lambda { Thrift.check_type(nil, Thrift::Types::STOP) }.should raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(3,              {:type => Thrift::Types::STOP},   :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(nil,            {:type => Thrift::Types::VOID},   :foo) }.not_to raise_error
-      expect { Thrift.check_type(3,              {:type => Thrift::Types::VOID},   :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(true,           {:type => Thrift::Types::BOOL},   :foo) }.not_to raise_error
-      expect { Thrift.check_type(3,              {:type => Thrift::Types::BOOL},   :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(42,             {:type => Thrift::Types::BYTE},   :foo) }.not_to raise_error
-      expect { Thrift.check_type(42,             {:type => Thrift::Types::I16},    :foo) }.not_to raise_error
-      expect { Thrift.check_type(42,             {:type => Thrift::Types::I32},    :foo) }.not_to raise_error
-      expect { Thrift.check_type(42,             {:type => Thrift::Types::I64},    :foo) }.not_to raise_error
-      expect { Thrift.check_type(3.14,           {:type => Thrift::Types::I32},    :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type(3.14,           {:type => Thrift::Types::DOUBLE}, :foo) }.not_to raise_error
-      expect { Thrift.check_type(3,              {:type => Thrift::Types::DOUBLE}, :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type("3",            {:type => Thrift::Types::STRING}, :foo) }.not_to raise_error
-      expect { Thrift.check_type(3,              {:type => Thrift::Types::STRING}, :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(3,               {:type => Thrift::Types::STOP},   :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil,             {:type => Thrift::Types::VOID},   :foo) }.not_to raise_error
+      expect { Thrift.check_type(3,               {:type => Thrift::Types::VOID},   :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(true,            {:type => Thrift::Types::BOOL},   :foo) }.not_to raise_error
+      expect { Thrift.check_type(3,               {:type => Thrift::Types::BOOL},   :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(42,              {:type => Thrift::Types::BYTE},   :foo) }.not_to raise_error
+      expect { Thrift.check_type(42,              {:type => Thrift::Types::I16},    :foo) }.not_to raise_error
+      expect { Thrift.check_type(42,              {:type => Thrift::Types::I32},    :foo) }.not_to raise_error
+      expect { Thrift.check_type(42,              {:type => Thrift::Types::I64},    :foo) }.not_to raise_error
+      expect { Thrift.check_type(3.14,            {:type => Thrift::Types::I32},    :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(3.14,            {:type => Thrift::Types::DOUBLE}, :foo) }.not_to raise_error
+      expect { Thrift.check_type(3,               {:type => Thrift::Types::DOUBLE}, :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type("3",             {:type => Thrift::Types::STRING}, :foo) }.not_to raise_error
+      expect { Thrift.check_type(3,               {:type => Thrift::Types::STRING}, :foo) }.to raise_error(Thrift::TypeError)
       hello = SpecNamespace::Hello.new
-      expect { Thrift.check_type(hello,          {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}, :foo) }.not_to raise_error
-      expect { Thrift.check_type("foo",          {:type => Thrift::Types::STRUCT}, :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(hello,           {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}, :foo) }.not_to raise_error
+      expect { Thrift.check_type("foo",           {:type => Thrift::Types::STRUCT}, :foo) }.to raise_error(Thrift::TypeError)
       field = {:type => Thrift::Types::MAP, :key => {:type => Thrift::Types::I32}, :value => {:type => Thrift::Types::STRING}}
-      expect { Thrift.check_type({1 => "one"},   field,                            :foo) }.not_to raise_error
-      expect { Thrift.check_type([1],            field,                            :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type({1 => "one"},    field,                            :foo) }.not_to raise_error
+      expect { Thrift.check_type([1],             field,                            :foo) }.to raise_error(Thrift::TypeError)
       field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::I32}}
-      expect { Thrift.check_type([1],            field,                            :foo) }.not_to raise_error
-      expect { Thrift.check_type({:foo => 1},    field,                            :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type([1],             field,                            :foo) }.not_to raise_error
+      expect { Thrift.check_type({:foo => 1},     field,                            :foo) }.to raise_error(Thrift::TypeError)
       field = {:type => Thrift::Types::SET, :element => {:type => Thrift::Types::I32}}
-      expect { Thrift.check_type(Set.new([1,2]), field,                            :foo) }.not_to raise_error
-      expect { Thrift.check_type([1,2],          field,                            :foo) }.to raise_error(Thrift::TypeError)
-      expect { Thrift.check_type({:foo => true}, field,                            :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(Set.new([1, 2]), field,                            :foo) }.not_to raise_error
+      expect { Thrift.check_type([1, 2],          field,                            :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type({:foo => true},  field,                            :foo) }.to raise_error(Thrift::TypeError)
     end
 
     it "should error out if nil is passed and skip_types is false" do
@@ -100,9 +99,9 @@ describe Thrift::Types do
     end
 
     it "should give the Thrift::TypeError a readable message" do
-      msg = /Expected Types::STRING, received (Integer|Fixnum) for field foo/
+      msg = "Expected Types::STRING, received Integer for field foo"
       expect { Thrift.check_type(3, {:type => Thrift::Types::STRING}, :foo) }.to raise_error(Thrift::TypeError, msg)
-      msg = /Expected Types::STRING, received (Integer|Fixnum) for field foo.element/
+      msg = "Expected Types::STRING, received Integer for field foo.element"
       field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::STRING}}
       expect { Thrift.check_type([3], field, :foo) }.to raise_error(Thrift::TypeError, msg)
       msg = "Expected Types::I32, received NilClass for field foo.element.key"

data/spec/union_spec.rb

@@ -20,7 +20,6 @@
 require 'spec_helper'
 
 describe 'Union' do
-
   describe Thrift::Union do
     it "should return nil value in unset union" do
       union = SpecNamespace::My_union.new
@@ -51,7 +50,9 @@ describe 'Union' do
     it "should raise for wrong set field when hash initialized and type checking is off" do
       Thrift.type_checking = false
       union = SpecNamespace::My_union.new({incorrect_field: :incorrect})
-      expect { Thrift::Serializer.new.serialize(union) }.to raise_error(RuntimeError, "set_field is not valid for this union!")
+      expect { Thrift::Serializer.new.serialize(union) }.to raise_error(Thrift::ProtocolException, "set_field is not valid for this union!") { |error|
+        expect(error.type).to eq(Thrift::ProtocolException::INVALID_DATA)
+      }
     end
 
     it "should not be equal to nil" do
@@ -91,6 +92,24 @@ describe 'Union' do
       expect(union).not_to eq(other_union)
     end
 
+    it "should equate two unions with the same UUID value" do
+      union = SpecNamespace::My_union.new(:unique_id, '550e8400-e29b-41d4-a716-446655440000')
+      other_union = SpecNamespace::My_union.new(:unique_id, '550e8400-e29b-41d4-a716-446655440000')
+      expect(union).to eq(other_union)
+    end
+
+    it "should not equate two unions with different UUID values" do
+      union = SpecNamespace::My_union.new(:unique_id, '550e8400-e29b-41d4-a716-446655440000')
+      other_union = SpecNamespace::My_union.new(:unique_id, '6ba7b810-9dad-11d1-80b4-00c04fd430c8')
+      expect(union).not_to eq(other_union)
+    end
+
+    it "should not equate UUID union with different field type" do
+      union = SpecNamespace::My_union.new(:unique_id, '550e8400-e29b-41d4-a716-446655440000')
+      other_union = SpecNamespace::My_union.new(:some_characters, '550e8400-e29b-41d4-a716-446655440000')
+      expect(union).not_to eq(other_union)
+    end
+
     it "should inspect properly" do
       union = SpecNamespace::My_union.new(:integer32, 25)
       expect(union.inspect).to eq("<SpecNamespace::My_union integer32: 25>")
@@ -130,7 +149,9 @@ describe 'Union' do
 
     it "should raise when validating unset union" do
       union = SpecNamespace::My_union.new
-      expect { union.validate }.to raise_error(StandardError, "Union fields are not set.")
+      expect { union.validate }.to raise_error(Thrift::ProtocolException, "Union fields are not set.") { |error|
+        expect(error.type).to eq(Thrift::ProtocolException::INVALID_DATA)
+      }
 
       other_union = SpecNamespace::My_union.new(:integer32, 1)
       expect { other_union.validate }.not_to raise_error
@@ -139,7 +160,9 @@ describe 'Union' do
     it "should validate an enum field properly" do
       union = SpecNamespace::TestUnion.new(:enum_field, 3)
       expect(union.get_set_field).to eq(:enum_field)
-      expect { union.validate }.to raise_error(Thrift::ProtocolException, "Invalid value of field enum_field!")
+      expect { union.validate }.to raise_error(Thrift::ProtocolException, "Invalid value of field enum_field!") { |error|
+        expect(error.type).to eq(Thrift::ProtocolException::INVALID_DATA)
+      }
 
       other_union = SpecNamespace::TestUnion.new(:enum_field, 1)
       expect { other_union.validate }.not_to raise_error
@@ -170,7 +193,7 @@ describe 'Union' do
     end
 
     it "should not throw an error when inspected and unset" do
-      expect{SpecNamespace::TestUnion.new().inspect}.not_to raise_error
+      expect{ SpecNamespace::TestUnion.new().inspect }.not_to raise_error
     end
 
     it "should print enum value name when inspected" do
@@ -192,23 +215,58 @@ describe 'Union' do
 
     it "should be comparable" do
       relationships = [
-        [0,   -1, -1, -1],
-        [1,   0,  -1, -1],
-        [1,   1,  0,  -1],
-        [1,   1,  1,  0]]
+        [0,   -1, -1, -1, -1, -1],
+        [1,   0,  -1, -1, -1, -1],
+        [1,   1,  0,  -1, -1, -1],
+        [1,   1,  1,  0,  -1, -1],
+        [1,   1,  1,  1,  0,  -1],
+        [1,   1,  1,  1,  1,  0]]
 
       objs = [
         SpecNamespace::TestUnion.new(:string_field, "blah"),
         SpecNamespace::TestUnion.new(:string_field, "blahblah"),
         SpecNamespace::TestUnion.new(:i32_field, 1),
+        SpecNamespace::TestUnion.new(:uuid_field, '550e8400-e29b-41d4-a716-446655440000'),
+        SpecNamespace::TestUnion.new(:uuid_field, '6ba7b810-9dad-11d1-80b4-00c04fd430c8'),
         SpecNamespace::TestUnion.new()]
 
-      for y in 0..3
-        for x in 0..3
+      objs.size.times do |y|
+        objs.size.times do |x|
           # puts "#{objs[y].inspect} <=> #{objs[x].inspect} should == #{relationships[y][x]}"
           expect(objs[y] <=> objs[x]).to eq(relationships[y][x])
         end
       end
     end
+
+    it "should handle UUID as union value" do
+      union = SpecNamespace::My_union.new
+      union.unique_id = 'ffffffff-ffff-ffff-ffff-ffffffffffff'
+
+      trans = Thrift::MemoryBufferTransport.new
+      prot = Thrift::CompactProtocol.new(trans)
+
+      union.write(prot)
+
+      result = SpecNamespace::My_union.new
+      result.read(prot)
+
+      expect(result.unique_id).to eq('ffffffff-ffff-ffff-ffff-ffffffffffff')
+      expect(result.get_set_field).to eq(:unique_id)
+    end
+
+    it "should normalize UUID case in union" do
+      union = SpecNamespace::My_union.new
+      union.unique_id = '550E8400-E29B-41D4-A716-446655440000'
+
+      trans = Thrift::MemoryBufferTransport.new
+      prot = Thrift::BinaryProtocol.new(trans)
+
+      union.write(prot)
+
+      result = SpecNamespace::My_union.new
+      result.read(prot)
+
+      expect(result.unique_id).to eq('550e8400-e29b-41d4-a716-446655440000')
+    end
   end
 end

data/spec/unix_socket_spec.rb

@@ -21,7 +21,6 @@ require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
 describe 'UNIXSocket' do
-
   describe Thrift::UNIXSocket do
     before(:each) do
       @path = '/tmp/thrift_spec_socket'
@@ -42,7 +41,7 @@ describe 'UNIXSocket' do
       allow(::UNIXSocket).to receive(:new)
       expect(Thrift::UNIXSocket.new(@path, 5).timeout).to eq(5)
     end
-    
+
     it "should provide a reasonable to_s" do
       allow(::UNIXSocket).to receive(:new)
       expect(Thrift::UNIXSocket.new(@path).to_s).to eq("domain(#{@path})")

data/spec/uuid_validation_spec.rb

@@ -0,0 +1,238 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+require 'spec_helper'
+
+describe 'UUID Validation' do
+  protocols = [
+    ['BinaryProtocol', Thrift::BinaryProtocol],
+  ]
+
+  if defined?(Thrift::BinaryProtocolAccelerated)
+    protocols << ['BinaryProtocolAccelerated', Thrift::BinaryProtocolAccelerated]
+  end
+
+  protocols << ['CompactProtocol', Thrift::CompactProtocol]
+  protocols << ['JsonProtocol', Thrift::JsonProtocol]
+
+  protocols.each do |protocol_name, protocol_class|
+    describe protocol_name do
+      before(:each) do
+        @trans = Thrift::MemoryBufferTransport.new
+        @prot = protocol_class.new(@trans)
+      end
+
+      context 'valid UUIDs' do
+        it 'should accept lowercase UUIDs' do
+          uuid = '550e8400-e29b-41d4-a716-446655440000'
+          expect { @prot.write_uuid(uuid) }.not_to raise_error
+          result = @prot.read_uuid
+          expect(result).to eq(uuid)
+        end
+
+        it 'should accept uppercase UUIDs' do
+          uuid = '550E8400-E29B-41D4-A716-446655440000'
+          expect { @prot.write_uuid(uuid) }.not_to raise_error
+          result = @prot.read_uuid
+          # Result should be lowercase
+          expect(result).to eq('550e8400-e29b-41d4-a716-446655440000')
+        end
+
+        it 'should accept mixed case UUIDs' do
+          uuid = '550e8400-E29B-41d4-A716-446655440000'
+          expect { @prot.write_uuid(uuid) }.not_to raise_error
+          result = @prot.read_uuid
+          expect(result).to eq('550e8400-e29b-41d4-a716-446655440000')
+        end
+
+        it 'should accept all zeros' do
+          uuid = '00000000-0000-0000-0000-000000000000'
+          expect { @prot.write_uuid(uuid) }.not_to raise_error
+          result = @prot.read_uuid
+          expect(result).to eq(uuid)
+        end
+
+        it 'should accept all fs' do
+          uuid = 'ffffffff-ffff-ffff-ffff-ffffffffffff'
+          expect { @prot.write_uuid(uuid) }.not_to raise_error
+          result = @prot.read_uuid
+          expect(result).to eq(uuid)
+        end
+      end
+
+      context 'invalid UUIDs' do
+        def expect_invalid_uuid(value, message)
+          expect { @prot.write_uuid(value) }.to raise_error(Thrift::ProtocolException) do |error|
+            expect(error.type).to eq(Thrift::ProtocolException::INVALID_DATA)
+            expect(error.message).to eq(message)
+          end
+        end
+
+        it 'should reject nil' do
+          expect_invalid_uuid(nil, 'UUID must be a string')
+        end
+
+        it 'should reject non-string' do
+          expect_invalid_uuid(12345, 'UUID must be a string')
+        end
+
+        it 'should reject wrong length' do
+          expect_invalid_uuid('550e8400-e29b-41d4-a716', 'Invalid UUID format')
+        end
+
+        it 'should reject missing hyphens' do
+          expect_invalid_uuid('550e8400e29b41d4a716446655440000', 'Invalid UUID format')
+        end
+
+        it 'should reject hyphens in wrong positions' do
+          expect_invalid_uuid('550e840-0e29b-41d4-a716-446655440000', 'Invalid UUID format')
+        end
+
+        it 'should reject invalid hex characters (g)' do
+          expect_invalid_uuid('550e8400-e29b-41d4-a716-44665544000g', 'Invalid UUID format')
+        end
+
+        it 'should reject invalid hex characters (z)' do
+          expect_invalid_uuid('z50e8400-e29b-41d4-a716-446655440000', 'Invalid UUID format')
+        end
+
+        it 'should reject invalid hex characters (space)' do
+          expect_invalid_uuid('550e8400-e29b-41d4-a716-44665544000 ', 'Invalid UUID format')
+        end
+
+        it 'should reject empty string' do
+          expect_invalid_uuid('', 'Invalid UUID format')
+        end
+
+        it 'should reject UUID with extra characters' do
+          expect_invalid_uuid('550e8400-e29b-41d4-a716-446655440000x', 'Invalid UUID format')
+        end
+
+        it 'should reject trailing hyphen' do
+          expect_invalid_uuid('550e8400-e29b-41d4-a716-44665544000-', 'Invalid UUID format')
+        end
+
+        it 'should reject hyphen inside hex pair' do
+          expect_invalid_uuid('550e8400-e29b-41d4-a716-4466-5544000', 'Invalid UUID format')
+        end
+      end
+
+      context 'malformed binary data on read' do
+        it 'should raise error on truncated data' do
+          @trans = Thrift::MemoryBufferTransport.new
+          @prot = protocol_class.new(@trans)
+
+          # Write only 10 bytes instead of 16
+          if protocol_class == Thrift::JsonProtocol
+            @trans.write('"00000000-0000-0000-0000"')
+          else
+            @trans.write("\x00" * 10)
+          end
+
+          expect { @prot.read_uuid }.to raise_error(EOFError)
+        end
+
+        it 'should raise error on 15 bytes (one byte short)' do
+          @trans = Thrift::MemoryBufferTransport.new
+          @prot = protocol_class.new(@trans)
+
+          if protocol_class == Thrift::JsonProtocol
+            @trans.write('"00000000-0000-0000-0000-000000000"')
+          else
+            @trans.write("\x00" * 15)
+          end
+
+          expect { @prot.read_uuid }.to raise_error(EOFError)
+        end
+
+        it 'should raise error on empty buffer' do
+          @trans = Thrift::MemoryBufferTransport.new
+          @prot = protocol_class.new(@trans)
+
+          expect { @prot.read_uuid }.to raise_error(EOFError)
+        end
+      end
+
+      context 'multiple UUIDs in sequence' do
+        it 'should handle 10 UUIDs in sequence' do
+          uuids = 10.times.map { |i| sprintf('%08x-0000-0000-0000-000000000000', i) }
+
+          @trans = Thrift::MemoryBufferTransport.new
+          @prot = protocol_class.new(@trans)
+
+          uuids.each { |uuid| @prot.write_uuid(uuid) }
+
+          results = 10.times.map { @prot.read_uuid }
+          expect(results).to eq(uuids)
+        end
+
+        it 'should handle UUIDs interleaved with other types' do
+          @trans = Thrift::MemoryBufferTransport.new
+          @prot = protocol_class.new(@trans)
+
+          @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 0)
+          @prot.write_i32(42)
+          @prot.write_uuid('550e8400-e29b-41d4-a716-446655440000')
+          @prot.write_string('test')
+          @prot.write_uuid('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
+          @prot.write_i64(123456789)
+          @prot.write_message_end
+
+          @prot.read_message_begin
+          expect(@prot.read_i32).to eq(42)
+          expect(@prot.read_uuid).to eq('550e8400-e29b-41d4-a716-446655440000')
+          expect(@prot.read_string).to eq('test')
+          expect(@prot.read_uuid).to eq('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
+          expect(@prot.read_i64).to eq(123456789)
+          @prot.read_message_end
+        end
+
+        it 'should handle UUIDs in struct fields context' do
+          @trans = Thrift::MemoryBufferTransport.new
+          @prot = protocol_class.new(@trans)
+
+          # Simulate struct field headers
+          @prot.write_struct_begin('test')
+          @prot.write_field_begin('uuid1', Thrift::Types::UUID, 1)
+          @prot.write_uuid('550e8400-e29b-41d4-a716-446655440000')
+          @prot.write_field_end
+          @prot.write_field_begin('uuid2', Thrift::Types::UUID, 2)
+          @prot.write_uuid('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
+          @prot.write_field_end
+          @prot.write_field_stop
+          @prot.write_struct_end
+
+          @prot.read_struct_begin
+          name, type, id = @prot.read_field_begin
+          expect(type).to eq(Thrift::Types::UUID)
+          expect(@prot.read_uuid).to eq('550e8400-e29b-41d4-a716-446655440000')
+          @prot.read_field_end
+
+          name, type, id = @prot.read_field_begin
+          expect(type).to eq(Thrift::Types::UUID)
+          expect(@prot.read_uuid).to eq('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
+          @prot.read_field_end
+
+          name, type, id = @prot.read_field_begin
+          expect(type).to eq(Thrift::Types::STOP)
+        end
+      end
+    end
+  end
+end