diff --git a/exporters/otlp/test/recordable_test.cc b/exporters/otlp/test/recordable_test.cc
index 034e79709b..62ced4ac6b 100644
--- a/exporters/otlp/test/recordable_test.cc
+++ b/exporters/otlp/test/recordable_test.cc
@@ -117,21 +117,21 @@ TEST(Recordable, AddEventWithAttributes)
 
 TEST(Recordable, AddLink)
 {
-//  Recordable rec;
-//  const int kNumAttributes              = 3;
-//  std::string keys[kNumAttributes]      = {"attr1", "attr2", "attr3"};
-//  int values[kNumAttributes]            = {5, 12, 40};
-//  std::map<std::string, int> attributes = {
-//      {keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}};
-//
-//  rec.AddLink(trace::SpanContext(false, false),
-//              trace::KeyValueIterableView<std::map<std::string, int>>(attributes));
-//
-//  for (int i = 0; i < kNumAttributes; i++)
-//  {
-//    EXPECT_EQ(rec.span().links(0).attributes(i).key(), keys[i]);
-//    EXPECT_EQ(rec.span().links(0).attributes(i).value().int_value(), values[i]);
-//  }
+  Recordable rec;
+  const int kNumAttributes              = 3;
+  std::string keys[kNumAttributes]      = {"attr1", "attr2", "attr3"};
+  int values[kNumAttributes]            = {5, 12, 40};
+  std::map<std::string, int> attributes = {
+      {keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}};
+
+  rec.AddLink(trace::SpanContext(false, false),
+              trace::KeyValueIterableView<std::map<std::string, int>>(attributes));
+
+  for (int i = 0; i < kNumAttributes; i++)
+  {
+    EXPECT_EQ(rec.span().links(0).attributes(i).key(), keys[i]);
+    EXPECT_EQ(rec.span().links(0).attributes(i).value().int_value(), values[i]);
+  }
 }
 
 // Test non-int single types. Int single types are tested using templates (see IntAttributeTest)
diff --git a/sdk/test/trace/parent_or_else_sampler_test.cc b/sdk/test/trace/parent_or_else_sampler_test.cc
index 922c17596d..311ffae59f 100644
--- a/sdk/test/trace/parent_or_else_sampler_test.cc
+++ b/sdk/test/trace/parent_or_else_sampler_test.cc
@@ -12,40 +12,40 @@ using opentelemetry::trace::SpanContext;
 
 TEST(ParentOrElseSampler, ShouldSample)
 {
-//  ParentOrElseSampler sampler_off(std::make_shared<AlwaysOffSampler>());
-//  ParentOrElseSampler sampler_on(std::make_shared<AlwaysOnSampler>());
-//
-//  // Set up parameters
-//  opentelemetry::trace::TraceId trace_id;
-//  opentelemetry::trace::SpanKind span_kind = opentelemetry::trace::SpanKind::kInternal;
-//  using M                                  = std::map<std::string, int>;
-//  M m1                                     = {{}};
-//  opentelemetry::trace::KeyValueIterableView<M> view{m1};
-//  SpanContext parent_context_sampled(true, false);
-//  SpanContext parent_context_nonsampled(false, false);
-//
-//  // Case 1: Parent doesn't exist. Return result of delegateSampler()
-//  auto sampling_result  = sampler_off.ShouldSample(nullptr, trace_id, "", span_kind, view);
-//  auto sampling_result2 = sampler_on.ShouldSample(nullptr, trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::NOT_RECORD, sampling_result.decision);
-//  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result2.decision);
-//
-//  // Case 2: Parent exists and SampledFlag is true
-//  auto sampling_result3 =
-//      sampler_off.ShouldSample(&parent_context_sampled, trace_id, "", span_kind, view);
-//  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result3.decision);
-//
-//  // Case 3: Parent exists and SampledFlag is false
-//  auto sampling_result4 =
-//      sampler_on.ShouldSample(&parent_context_nonsampled, trace_id, "", span_kind, view);
-//  ASSERT_EQ(Decision::NOT_RECORD, sampling_result4.decision);
+  ParentOrElseSampler sampler_off(std::make_shared<AlwaysOffSampler>());
+  ParentOrElseSampler sampler_on(std::make_shared<AlwaysOnSampler>());
+
+  // Set up parameters
+  opentelemetry::trace::TraceId trace_id;
+  opentelemetry::trace::SpanKind span_kind = opentelemetry::trace::SpanKind::kInternal;
+  using M                                  = std::map<std::string, int>;
+  M m1                                     = {{}};
+  opentelemetry::trace::KeyValueIterableView<M> view{m1};
+  SpanContext parent_context_sampled(true, false);
+  SpanContext parent_context_nonsampled(false, false);
+
+  // Case 1: Parent doesn't exist. Return result of delegateSampler()
+  auto sampling_result  = sampler_off.ShouldSample(nullptr, trace_id, "", span_kind, view);
+  auto sampling_result2 = sampler_on.ShouldSample(nullptr, trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::NOT_RECORD, sampling_result.decision);
+  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result2.decision);
+
+  // Case 2: Parent exists and SampledFlag is true
+  auto sampling_result3 =
+      sampler_off.ShouldSample(&parent_context_sampled, trace_id, "", span_kind, view);
+  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result3.decision);
+
+  // Case 3: Parent exists and SampledFlag is false
+  auto sampling_result4 =
+      sampler_on.ShouldSample(&parent_context_nonsampled, trace_id, "", span_kind, view);
+  ASSERT_EQ(Decision::NOT_RECORD, sampling_result4.decision);
 }
 
 TEST(ParentOrElseSampler, GetDescription)
 {
-//  ParentOrElseSampler sampler(std::make_shared<AlwaysOffSampler>());
-//  ASSERT_EQ("ParentOrElse{AlwaysOffSampler}", sampler.GetDescription());
-//  ParentOrElseSampler sampler2(std::make_shared<AlwaysOnSampler>());
-//  ASSERT_EQ("ParentOrElse{AlwaysOnSampler}", sampler2.GetDescription());
+  ParentOrElseSampler sampler(std::make_shared<AlwaysOffSampler>());
+  ASSERT_EQ("ParentOrElse{AlwaysOffSampler}", sampler.GetDescription());
+  ParentOrElseSampler sampler2(std::make_shared<AlwaysOnSampler>());
+  ASSERT_EQ("ParentOrElse{AlwaysOnSampler}", sampler2.GetDescription());
 }
diff --git a/sdk/test/trace/probability_sampler_test.cc b/sdk/test/trace/probability_sampler_test.cc
index 8fbb123c1d..75a11a1fc7 100644
--- a/sdk/test/trace/probability_sampler_test.cc
+++ b/sdk/test/trace/probability_sampler_test.cc
@@ -24,197 +24,197 @@ namespace
  * generate a random trace_id and check if it should sample using the provided
  * provider and context
  */
-//int RunShouldSampleCountDecision(SpanContext &context, ProbabilitySampler &sampler, int iterations)
-//{
-//  int actual_count = 0;
-//
-//  opentelemetry::trace::SpanKind span_kind = opentelemetry::trace::SpanKind::kInternal;
-//
-//  using M = std::map<std::string, int>;
-//  M m1    = {{}};
-//  opentelemetry::trace::KeyValueIterableView<M> view{m1};
-//
-//  for (int i = 0; i < iterations; ++i)
-//  {
-//    uint8_t buf[16] = {0};
-//    Random::GenerateRandomBuffer(buf);
-//
-//    opentelemetry::trace::TraceId trace_id(buf);
-//
-//    auto result = sampler.ShouldSample(&context, trace_id, "", span_kind, view);
-//    if (result.decision == Decision::RECORD_AND_SAMPLE)
-//    {
-//      ++actual_count;
-//    }
-//  }
-//
-//  return actual_count;
-//}
+int RunShouldSampleCountDecision(SpanContext &context, ProbabilitySampler &sampler, int iterations)
+{
+  int actual_count = 0;
+
+  opentelemetry::trace::SpanKind span_kind = opentelemetry::trace::SpanKind::kInternal;
+
+  using M = std::map<std::string, int>;
+  M m1    = {{}};
+  opentelemetry::trace::KeyValueIterableView<M> view{m1};
+
+  for (int i = 0; i < iterations; ++i)
+  {
+    uint8_t buf[16] = {0};
+    Random::GenerateRandomBuffer(buf);
+
+    opentelemetry::trace::TraceId trace_id(buf);
+
+    auto result = sampler.ShouldSample(&context, trace_id, "", span_kind, view);
+    if (result.decision == Decision::RECORD_AND_SAMPLE)
+    {
+      ++actual_count;
+    }
+  }
+
+  return actual_count;
+}
 }  // namespace
 
 TEST(ProbabilitySampler, ShouldSampleWithoutContext)
 {
-//  opentelemetry::trace::TraceId invalid_trace_id;
-//
-//  opentelemetry::trace::SpanKind span_kind = opentelemetry::trace::SpanKind::kInternal;
-//
-//  using M = std::map<std::string, int>;
-//  M m1    = {{}};
-//  opentelemetry::trace::KeyValueIterableView<M> view{m1};
-//
-//  ProbabilitySampler s1(0.01);
-//
-//  auto sampling_result = s1.ShouldSample(nullptr, invalid_trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
-//
-//  constexpr uint8_t buf[] = {0, 0, 0, 0, 0, 0, 0, 0x80, 0, 0, 0, 0, 0, 0, 0, 0};
-//  opentelemetry::trace::TraceId valid_trace_id(buf);
-//
-//  sampling_result = s1.ShouldSample(nullptr, valid_trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::NOT_RECORD, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
-//
-//  ProbabilitySampler s2(0.50000001);
-//
-//  sampling_result = s2.ShouldSample(nullptr, valid_trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
-//
-//  ProbabilitySampler s3(0.49999999);
-//
-//  sampling_result = s3.ShouldSample(nullptr, valid_trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::NOT_RECORD, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
-//
-//  ProbabilitySampler s4(0.50000000);
-//
-//  sampling_result = s4.ShouldSample(nullptr, valid_trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
+  opentelemetry::trace::TraceId invalid_trace_id;
+
+  opentelemetry::trace::SpanKind span_kind = opentelemetry::trace::SpanKind::kInternal;
+
+  using M = std::map<std::string, int>;
+  M m1    = {{}};
+  opentelemetry::trace::KeyValueIterableView<M> view{m1};
+
+  ProbabilitySampler s1(0.01);
+
+  auto sampling_result = s1.ShouldSample(nullptr, invalid_trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
+
+  constexpr uint8_t buf[] = {0, 0, 0, 0, 0, 0, 0, 0x80, 0, 0, 0, 0, 0, 0, 0, 0};
+  opentelemetry::trace::TraceId valid_trace_id(buf);
+
+  sampling_result = s1.ShouldSample(nullptr, valid_trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::NOT_RECORD, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
+
+  ProbabilitySampler s2(0.50000001);
+
+  sampling_result = s2.ShouldSample(nullptr, valid_trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
+
+  ProbabilitySampler s3(0.49999999);
+
+  sampling_result = s3.ShouldSample(nullptr, valid_trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::NOT_RECORD, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
+
+  ProbabilitySampler s4(0.50000000);
+
+  sampling_result = s4.ShouldSample(nullptr, valid_trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
 }
 
 TEST(ProbabilitySampler, ShouldSampleWithContext)
 {
-//  opentelemetry::trace::TraceId trace_id;
-//  opentelemetry::trace::SpanKind span_kind = opentelemetry::trace::SpanKind::kInternal;
-//  SpanContext c1(false, false);
-//  SpanContext c2(true, false);
-//  SpanContext c3(false, true);
-//  SpanContext c4(true, true);
-//
-//  using M = std::map<std::string, int>;
-//  M m1    = {{}};
-//  opentelemetry::trace::KeyValueIterableView<M> view{m1};
-//
-//  ProbabilitySampler s1(0.01);
-//
-//  auto sampling_result = s1.ShouldSample(&c1, trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::NOT_RECORD, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
-//
-//  sampling_result = s1.ShouldSample(&c2, trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
-//
-//  sampling_result = s1.ShouldSample(&c3, trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
-//
-//  sampling_result = s1.ShouldSample(&c4, trace_id, "", span_kind, view);
-//
-//  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
-//  ASSERT_EQ(nullptr, sampling_result.attributes);
+  opentelemetry::trace::TraceId trace_id;
+  opentelemetry::trace::SpanKind span_kind = opentelemetry::trace::SpanKind::kInternal;
+  SpanContext c1(false, false);
+  SpanContext c2(true, false);
+  SpanContext c3(false, true);
+  SpanContext c4(true, true);
+
+  using M = std::map<std::string, int>;
+  M m1    = {{}};
+  opentelemetry::trace::KeyValueIterableView<M> view{m1};
+
+  ProbabilitySampler s1(0.01);
+
+  auto sampling_result = s1.ShouldSample(&c1, trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::NOT_RECORD, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
+
+  sampling_result = s1.ShouldSample(&c2, trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
+
+  sampling_result = s1.ShouldSample(&c3, trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
+
+  sampling_result = s1.ShouldSample(&c4, trace_id, "", span_kind, view);
+
+  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
+  ASSERT_EQ(nullptr, sampling_result.attributes);
 }
 
 TEST(ProbabilitySampler, ProbabilitySamplerHalf)
 {
-//  double probability = 0.5;
-//  int iterations = 100000, expected_count = iterations * probability, variance = iterations * 0.01;
-//
-//  SpanContext c(true, true);
-//  ProbabilitySampler s(probability);
-//
-//  int actual_count = RunShouldSampleCountDecision(c, s, iterations);
-//
-//  ASSERT_TRUE(actual_count < (expected_count + variance));
-//  ASSERT_TRUE(actual_count > (expected_count - variance));
+  double probability = 0.5;
+  int iterations = 100000, expected_count = iterations * probability, variance = iterations * 0.01;
+
+  SpanContext c(true, true);
+  ProbabilitySampler s(probability);
+
+  int actual_count = RunShouldSampleCountDecision(c, s, iterations);
+
+  ASSERT_TRUE(actual_count < (expected_count + variance));
+  ASSERT_TRUE(actual_count > (expected_count - variance));
 }
 
 TEST(ProbabilitySampler, ProbabilitySamplerOnePercent)
 {
-//  double probability = 0.01;
-//  int iterations = 100000, expected_count = iterations * probability, variance = iterations * 0.01;
-//
-//  SpanContext c(true, true);
-//  ProbabilitySampler s(probability);
-//
-//  int actual_count = RunShouldSampleCountDecision(c, s, iterations);
-//
-//  ASSERT_TRUE(actual_count < (expected_count + variance));
-//  ASSERT_TRUE(actual_count > (expected_count - variance));
+  double probability = 0.01;
+  int iterations = 100000, expected_count = iterations * probability, variance = iterations * 0.01;
+
+  SpanContext c(true, true);
+  ProbabilitySampler s(probability);
+
+  int actual_count = RunShouldSampleCountDecision(c, s, iterations);
+
+  ASSERT_TRUE(actual_count < (expected_count + variance));
+  ASSERT_TRUE(actual_count > (expected_count - variance));
 }
 
 TEST(ProbabilitySampler, ProbabilitySamplerAll)
 {
-//  double probability = 1.0;
-//  int iterations = 100000, expected_count = iterations * probability;
-//
-//  SpanContext c(true, true);
-//  ProbabilitySampler s(probability);
-//
-//  int actual_count = RunShouldSampleCountDecision(c, s, iterations);
-//
-//  ASSERT_EQ(actual_count, expected_count);
+  double probability = 1.0;
+  int iterations = 100000, expected_count = iterations * probability;
+
+  SpanContext c(true, true);
+  ProbabilitySampler s(probability);
+
+  int actual_count = RunShouldSampleCountDecision(c, s, iterations);
+
+  ASSERT_EQ(actual_count, expected_count);
 }
 
 TEST(ProbabilitySampler, ProbabilitySamplerNone)
 {
-//  double probability = 0.0;
-//  int iterations = 100000, expected_count = iterations * probability;
-//
-//  SpanContext c(true, true);
-//  ProbabilitySampler s(probability);
-//
-//  int actual_count = RunShouldSampleCountDecision(c, s, iterations);
-//
-//  ASSERT_EQ(actual_count, expected_count);
+  double probability = 0.0;
+  int iterations = 100000, expected_count = iterations * probability;
+
+  SpanContext c(true, true);
+  ProbabilitySampler s(probability);
+
+  int actual_count = RunShouldSampleCountDecision(c, s, iterations);
+
+  ASSERT_EQ(actual_count, expected_count);
 }
 
 TEST(ProbabilitySampler, GetDescription)
 {
-//  ProbabilitySampler s1(0.01);
-//  ASSERT_EQ("ProbabilitySampler{0.010000}", s1.GetDescription());
-//
-//  ProbabilitySampler s2(0.00);
-//  ASSERT_EQ("ProbabilitySampler{0.000000}", s2.GetDescription());
-//
-//  ProbabilitySampler s3(1.00);
-//  ASSERT_EQ("ProbabilitySampler{1.000000}", s3.GetDescription());
-//
-//  ProbabilitySampler s4(0.102030405);
-//  ASSERT_EQ("ProbabilitySampler{0.102030}", s4.GetDescription());
-//
-//  ProbabilitySampler s5(3.00);
-//  ASSERT_EQ("ProbabilitySampler{1.000000}", s5.GetDescription());
-//
-//  ProbabilitySampler s6(-3.00);
-//  ASSERT_EQ("ProbabilitySampler{0.000000}", s6.GetDescription());
-//
-//  ProbabilitySampler s7(1.00000000001);
-//  ASSERT_EQ("ProbabilitySampler{1.000000}", s7.GetDescription());
-//
-//  ProbabilitySampler s8(-1.00000000001);
-//  ASSERT_EQ("ProbabilitySampler{0.000000}", s8.GetDescription());
-//
-//  ProbabilitySampler s9(0.50);
-//  ASSERT_EQ("ProbabilitySampler{0.500000}", s9.GetDescription());
+  ProbabilitySampler s1(0.01);
+  ASSERT_EQ("ProbabilitySampler{0.010000}", s1.GetDescription());
+
+  ProbabilitySampler s2(0.00);
+  ASSERT_EQ("ProbabilitySampler{0.000000}", s2.GetDescription());
+
+  ProbabilitySampler s3(1.00);
+  ASSERT_EQ("ProbabilitySampler{1.000000}", s3.GetDescription());
+
+  ProbabilitySampler s4(0.102030405);
+  ASSERT_EQ("ProbabilitySampler{0.102030}", s4.GetDescription());
+
+  ProbabilitySampler s5(3.00);
+  ASSERT_EQ("ProbabilitySampler{1.000000}", s5.GetDescription());
+
+  ProbabilitySampler s6(-3.00);
+  ASSERT_EQ("ProbabilitySampler{0.000000}", s6.GetDescription());
+
+  ProbabilitySampler s7(1.00000000001);
+  ASSERT_EQ("ProbabilitySampler{1.000000}", s7.GetDescription());
+
+  ProbabilitySampler s8(-1.00000000001);
+  ASSERT_EQ("ProbabilitySampler{0.000000}", s8.GetDescription());
+
+  ProbabilitySampler s9(0.50);
+  ASSERT_EQ("ProbabilitySampler{0.500000}", s9.GetDescription());
 }