This is an automated email from the ASF dual-hosted git repository.

lostluck pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/beam.git


The following commit(s) were added to refs/heads/master by this push:
     new 028becb  Go redundant type cleanup. (#13348)
028becb is described below

commit 028becbabc4ba57a9158648a09e0846bb1a037ad
Author: Daniel Oliveira <[email protected]>
AuthorDate: Mon Nov 16 14:23:43 2020 -0800

    Go redundant type cleanup. (#13348)
    
    Cleaning up some stylistic warnings about redundant types. No actual 
changes to behavior.
---
 sdks/go/pkg/beam/core/runtime/graphx/translate.go  |   2 +-
 .../pkg/beam/core/runtime/xlangx/namespace_test.go | 344 ++++++++++-----------
 2 files changed, 173 insertions(+), 173 deletions(-)

diff --git a/sdks/go/pkg/beam/core/runtime/graphx/translate.go 
b/sdks/go/pkg/beam/core/runtime/graphx/translate.go
index 4957b75..17e8134 100644
--- a/sdks/go/pkg/beam/core/runtime/graphx/translate.go
+++ b/sdks/go/pkg/beam/core/runtime/graphx/translate.go
@@ -99,7 +99,7 @@ func CreateEnvironment(ctx context.Context, urn string, 
extractEnvironmentConfig
                Payload:      serializedPayload,
                Capabilities: goCapabilities(),
                Dependencies: []*pipepb.ArtifactInformation{
-                       &pipepb.ArtifactInformation{
+                       {
                                TypeUrn: URNArtifactGoWorker,
                                RoleUrn: URNArtifactStagingTo,
                                RolePayload: 
protox.MustEncode(&pipepb.ArtifactStagingToRolePayload{
diff --git a/sdks/go/pkg/beam/core/runtime/xlangx/namespace_test.go 
b/sdks/go/pkg/beam/core/runtime/xlangx/namespace_test.go
index 114567d..49b2e20 100644
--- a/sdks/go/pkg/beam/core/runtime/xlangx/namespace_test.go
+++ b/sdks/go/pkg/beam/core/runtime/xlangx/namespace_test.go
@@ -43,25 +43,25 @@ func TestAddNamespace(t *testing.T) {
                        name: "[Correctness] Single Input Multi Output",
                        init: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1", "t0o1": "p2"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p3"},
                                                EnvironmentId: "e1",
                                        },
-                                       "t2": &pipepb.PTransform{
+                                       "t2": {
                                                UniqueName:    "t2",
                                                Inputs:        
map[string]string{"t2i0": "p2"},
                                                Outputs:       
map[string]string{"t2o0": "p4"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t3": &pipepb.PTransform{
+                                       "t3": {
                                                UniqueName:    "t3",
                                                Inputs:        
map[string]string{"t3i0": "p3", "t3i1": "p4"},
                                                Outputs:       
map[string]string{"t3o0": "p5"},
@@ -69,52 +69,52 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1", WindowingStrategyId: "w1"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
-                                       "p3": &pipepb.PCollection{CoderId: 
"c3", WindowingStrategyId: "w1"},
-                                       "p4": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w0"},
-                                       "p5": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w1"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w1"},
+                                       "p1": {CoderId: "c1", 
WindowingStrategyId: "w1"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1"},
+                                       "p3": {CoderId: "c3", 
WindowingStrategyId: "w1"},
+                                       "p4": {CoderId: "c2", 
WindowingStrategyId: "w0"},
+                                       "p5": {CoderId: "c2", 
WindowingStrategyId: "w1"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0": 
&pipepb.WindowingStrategy{WindowCoderId: "c3", EnvironmentId: "e0"},
-                                       "w1": 
&pipepb.WindowingStrategy{WindowCoderId: "c4", EnvironmentId: "e1"},
+                                       "w0": {WindowCoderId: "c3", 
EnvironmentId: "e0"},
+                                       "w1": {WindowCoderId: "c4", 
EnvironmentId: "e1"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
-                                       "c1": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
-                                       "c2": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
-                                       "c3": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
-                                       "c4": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
+                                       "c0": {Spec: &pipepb.FunctionSpec{Urn: 
"c0"}},
+                                       "c1": {Spec: &pipepb.FunctionSpec{Urn: 
"c1"}},
+                                       "c2": {Spec: &pipepb.FunctionSpec{Urn: 
"c2"}},
+                                       "c3": {Spec: &pipepb.FunctionSpec{Urn: 
"c3"}},
+                                       "c4": {Spec: &pipepb.FunctionSpec{Urn: 
"c4"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0": &pipepb.Environment{Urn: "e0"},
-                                       "e1": &pipepb.Environment{Urn: "e1"},
+                                       "e0": {Urn: "e0"},
+                                       "e1": {Urn: "e1"},
                                },
                        },
                        namespace:   "daASxQwenJ",
                        transformID: "t0",
                        want: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1", "t0o1": "p2"},
                                                EnvironmentId: "e0@daASxQwenJ",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p3"},
                                                EnvironmentId: "e1@daASxQwenJ",
                                        },
-                                       "t2": &pipepb.PTransform{
+                                       "t2": {
                                                UniqueName:    "t2",
                                                Inputs:        
map[string]string{"t2i0": "p2"},
                                                Outputs:       
map[string]string{"t2o0": "p4"},
                                                EnvironmentId: "e0@daASxQwenJ",
                                        },
-                                       "t3": &pipepb.PTransform{
+                                       "t3": {
                                                UniqueName:    "t3",
                                                Inputs:        
map[string]string{"t3i0": "p3", "t3i1": "p4"},
                                                Outputs:       
map[string]string{"t3o0": "p5"},
@@ -122,27 +122,27 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p3": &pipepb.PCollection{CoderId: 
"c3", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p4": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w0"},
-                                       "p5": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p0": {CoderId: "c0@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p1": {CoderId: "c1@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p2": {CoderId: "c0@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p3": {CoderId: "c3", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p4": {CoderId: "c2", 
WindowingStrategyId: "w0"},
+                                       "p5": {CoderId: "c2", 
WindowingStrategyId: "w1@daASxQwenJ"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0":            
&pipepb.WindowingStrategy{WindowCoderId: "c3", EnvironmentId: "e0"},
-                                       "w1@daASxQwenJ": 
&pipepb.WindowingStrategy{WindowCoderId: "c4@daASxQwenJ", EnvironmentId: 
"e1@daASxQwenJ"},
+                                       "w0":            {WindowCoderId: "c3", 
EnvironmentId: "e0"},
+                                       "w1@daASxQwenJ": {WindowCoderId: 
"c4@daASxQwenJ", EnvironmentId: "e1@daASxQwenJ"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
-                                       "c1@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
-                                       "c2":            &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
-                                       "c3":            &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
-                                       "c4@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
+                                       "c0@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
+                                       "c1@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
+                                       "c2":            {Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
+                                       "c3":            {Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
+                                       "c4@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0@daASxQwenJ": 
&pipepb.Environment{Urn: "e0"},
-                                       "e1@daASxQwenJ": 
&pipepb.Environment{Urn: "e1"},
+                                       "e0@daASxQwenJ": {Urn: "e0"},
+                                       "e1@daASxQwenJ": {Urn: "e1"},
                                },
                        },
                },
@@ -150,25 +150,25 @@ func TestAddNamespace(t *testing.T) {
                        name: "[Correctness] Single Input Single Output",
                        init: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1", "t0o1": "p2"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p3"},
                                                EnvironmentId: "e1",
                                        },
-                                       "t2": &pipepb.PTransform{
+                                       "t2": {
                                                UniqueName:    "t2",
                                                Inputs:        
map[string]string{"t2i0": "p2"},
                                                Outputs:       
map[string]string{"t2o0": "p4"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t3": &pipepb.PTransform{
+                                       "t3": {
                                                UniqueName:    "t3",
                                                Inputs:        
map[string]string{"t3i0": "p3", "t3i1": "p4"},
                                                Outputs:       
map[string]string{"t3o0": "p5"},
@@ -176,52 +176,52 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1", WindowingStrategyId: "w1"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
-                                       "p3": &pipepb.PCollection{CoderId: 
"c3", WindowingStrategyId: "w1"},
-                                       "p4": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w0"},
-                                       "p5": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w1"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w1"},
+                                       "p1": {CoderId: "c1", 
WindowingStrategyId: "w1"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1"},
+                                       "p3": {CoderId: "c3", 
WindowingStrategyId: "w1"},
+                                       "p4": {CoderId: "c2", 
WindowingStrategyId: "w0"},
+                                       "p5": {CoderId: "c2", 
WindowingStrategyId: "w1"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0": 
&pipepb.WindowingStrategy{WindowCoderId: "c3", EnvironmentId: "e0"},
-                                       "w1": 
&pipepb.WindowingStrategy{WindowCoderId: "c4", EnvironmentId: "e1"},
+                                       "w0": {WindowCoderId: "c3", 
EnvironmentId: "e0"},
+                                       "w1": {WindowCoderId: "c4", 
EnvironmentId: "e1"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
-                                       "c1": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
-                                       "c2": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
-                                       "c3": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
-                                       "c4": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
+                                       "c0": {Spec: &pipepb.FunctionSpec{Urn: 
"c0"}},
+                                       "c1": {Spec: &pipepb.FunctionSpec{Urn: 
"c1"}},
+                                       "c2": {Spec: &pipepb.FunctionSpec{Urn: 
"c2"}},
+                                       "c3": {Spec: &pipepb.FunctionSpec{Urn: 
"c3"}},
+                                       "c4": {Spec: &pipepb.FunctionSpec{Urn: 
"c4"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0": &pipepb.Environment{Urn: "e0"},
-                                       "e1": &pipepb.Environment{Urn: "e1"},
+                                       "e0": {Urn: "e0"},
+                                       "e1": {Urn: "e1"},
                                },
                        },
                        namespace:   "daASxQwenJ",
                        transformID: "t1",
                        want: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1", "t0o1": "p2"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p3"},
                                                EnvironmentId: "e1@daASxQwenJ",
                                        },
-                                       "t2": &pipepb.PTransform{
+                                       "t2": {
                                                UniqueName:    "t2",
                                                Inputs:        
map[string]string{"t2i0": "p2"},
                                                Outputs:       
map[string]string{"t2o0": "p4"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t3": &pipepb.PTransform{
+                                       "t3": {
                                                UniqueName:    "t3",
                                                Inputs:        
map[string]string{"t3i0": "p3", "t3i1": "p4"},
                                                Outputs:       
map[string]string{"t3o0": "p5"},
@@ -229,27 +229,27 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p3": &pipepb.PCollection{CoderId: 
"c3@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p4": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w0"},
-                                       "p5": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p1": {CoderId: "c1@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p3": {CoderId: "c3@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p4": {CoderId: "c2", 
WindowingStrategyId: "w0"},
+                                       "p5": {CoderId: "c2", 
WindowingStrategyId: "w1@daASxQwenJ"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0":            
&pipepb.WindowingStrategy{WindowCoderId: "c3", EnvironmentId: "e0"},
-                                       "w1@daASxQwenJ": 
&pipepb.WindowingStrategy{WindowCoderId: "c4@daASxQwenJ", EnvironmentId: 
"e1@daASxQwenJ"},
+                                       "w0":            {WindowCoderId: "c3", 
EnvironmentId: "e0"},
+                                       "w1@daASxQwenJ": {WindowCoderId: 
"c4@daASxQwenJ", EnvironmentId: "e1@daASxQwenJ"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0":            &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
-                                       "c1@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
-                                       "c2":            &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
-                                       "c3@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
-                                       "c4@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
+                                       "c0":            {Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
+                                       "c1@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
+                                       "c2":            {Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
+                                       "c3@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
+                                       "c4@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0":            
&pipepb.Environment{Urn: "e0"},
-                                       "e1@daASxQwenJ": 
&pipepb.Environment{Urn: "e1"},
+                                       "e0":            {Urn: "e0"},
+                                       "e1@daASxQwenJ": {Urn: "e1"},
                                },
                        },
                },
@@ -257,25 +257,25 @@ func TestAddNamespace(t *testing.T) {
                        name: "[Correctness] Multi Input Single Output",
                        init: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1", "t0o1": "p2"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p3"},
                                                EnvironmentId: "e1",
                                        },
-                                       "t2": &pipepb.PTransform{
+                                       "t2": {
                                                UniqueName:    "t2",
                                                Inputs:        
map[string]string{"t2i0": "p2"},
                                                Outputs:       
map[string]string{"t2o0": "p4"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t3": &pipepb.PTransform{
+                                       "t3": {
                                                UniqueName:    "t3",
                                                Inputs:        
map[string]string{"t3i0": "p3", "t3i1": "p4"},
                                                Outputs:       
map[string]string{"t3o0": "p5"},
@@ -283,52 +283,52 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1", WindowingStrategyId: "w1"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
-                                       "p3": &pipepb.PCollection{CoderId: 
"c3", WindowingStrategyId: "w1"},
-                                       "p4": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w0"},
-                                       "p5": &pipepb.PCollection{CoderId: 
"c2", WindowingStrategyId: "w1"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w1"},
+                                       "p1": {CoderId: "c1", 
WindowingStrategyId: "w1"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1"},
+                                       "p3": {CoderId: "c3", 
WindowingStrategyId: "w1"},
+                                       "p4": {CoderId: "c2", 
WindowingStrategyId: "w0"},
+                                       "p5": {CoderId: "c2", 
WindowingStrategyId: "w1"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0": 
&pipepb.WindowingStrategy{WindowCoderId: "c3", EnvironmentId: "e0"},
-                                       "w1": 
&pipepb.WindowingStrategy{WindowCoderId: "c4", EnvironmentId: "e1"},
+                                       "w0": {WindowCoderId: "c3", 
EnvironmentId: "e0"},
+                                       "w1": {WindowCoderId: "c4", 
EnvironmentId: "e1"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
-                                       "c1": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
-                                       "c2": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
-                                       "c3": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
-                                       "c4": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
+                                       "c0": {Spec: &pipepb.FunctionSpec{Urn: 
"c0"}},
+                                       "c1": {Spec: &pipepb.FunctionSpec{Urn: 
"c1"}},
+                                       "c2": {Spec: &pipepb.FunctionSpec{Urn: 
"c2"}},
+                                       "c3": {Spec: &pipepb.FunctionSpec{Urn: 
"c3"}},
+                                       "c4": {Spec: &pipepb.FunctionSpec{Urn: 
"c4"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0": &pipepb.Environment{Urn: "e0"},
-                                       "e1": &pipepb.Environment{Urn: "e1"},
+                                       "e0": {Urn: "e0"},
+                                       "e1": {Urn: "e1"},
                                },
                        },
                        namespace:   "daASxQwenJ",
                        transformID: "t3",
                        want: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1", "t0o1": "p2"},
                                                EnvironmentId: "e0@daASxQwenJ",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p3"},
                                                EnvironmentId: "e1@daASxQwenJ",
                                        },
-                                       "t2": &pipepb.PTransform{
+                                       "t2": {
                                                UniqueName:    "t2",
                                                Inputs:        
map[string]string{"t2i0": "p2"},
                                                Outputs:       
map[string]string{"t2o0": "p4"},
                                                EnvironmentId: "e0@daASxQwenJ",
                                        },
-                                       "t3": &pipepb.PTransform{
+                                       "t3": {
                                                UniqueName:    "t3",
                                                Inputs:        
map[string]string{"t3i0": "p3", "t3i1": "p4"},
                                                Outputs:       
map[string]string{"t3o0": "p5"},
@@ -336,27 +336,27 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p3": &pipepb.PCollection{CoderId: 
"c3@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p4": &pipepb.PCollection{CoderId: 
"c2@daASxQwenJ", WindowingStrategyId: "w0@daASxQwenJ"},
-                                       "p5": &pipepb.PCollection{CoderId: 
"c2@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p1": {CoderId: "c1", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p3": {CoderId: "c3@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p4": {CoderId: "c2@daASxQwenJ", 
WindowingStrategyId: "w0@daASxQwenJ"},
+                                       "p5": {CoderId: "c2@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0@daASxQwenJ": 
&pipepb.WindowingStrategy{WindowCoderId: "c3@daASxQwenJ", EnvironmentId: 
"e0@daASxQwenJ"},
-                                       "w1@daASxQwenJ": 
&pipepb.WindowingStrategy{WindowCoderId: "c4@daASxQwenJ", EnvironmentId: 
"e1@daASxQwenJ"},
+                                       "w0@daASxQwenJ": {WindowCoderId: 
"c3@daASxQwenJ", EnvironmentId: "e0@daASxQwenJ"},
+                                       "w1@daASxQwenJ": {WindowCoderId: 
"c4@daASxQwenJ", EnvironmentId: "e1@daASxQwenJ"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0":            &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
-                                       "c1":            &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
-                                       "c2@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
-                                       "c3@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
-                                       "c4@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
+                                       "c0":            {Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
+                                       "c1":            {Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
+                                       "c2@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
+                                       "c3@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
+                                       "c4@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0@daASxQwenJ": 
&pipepb.Environment{Urn: "e0"},
-                                       "e1@daASxQwenJ": 
&pipepb.Environment{Urn: "e1"},
+                                       "e0@daASxQwenJ": {Urn: "e0"},
+                                       "e1@daASxQwenJ": {Urn: "e1"},
                                },
                        },
                },
@@ -364,13 +364,13 @@ func TestAddNamespace(t *testing.T) {
                        name: "[Correctness] Component Coders",
                        init: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p2"},
@@ -378,37 +378,37 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w0"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1", WindowingStrategyId: "w1"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w0"},
+                                       "p1": {CoderId: "c1", 
WindowingStrategyId: "w1"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0": 
&pipepb.WindowingStrategy{WindowCoderId: "c3", EnvironmentId: "e0"},
-                                       "w1": 
&pipepb.WindowingStrategy{WindowCoderId: "c4", EnvironmentId: "e1"},
+                                       "w0": {WindowCoderId: "c3", 
EnvironmentId: "e0"},
+                                       "w1": {WindowCoderId: "c4", 
EnvironmentId: "e1"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}, ComponentCoderIds: []string{"c2"}},
-                                       "c1": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
-                                       "c2": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
-                                       "c3": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
-                                       "c4": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
+                                       "c0": {Spec: &pipepb.FunctionSpec{Urn: 
"c0"}, ComponentCoderIds: []string{"c2"}},
+                                       "c1": {Spec: &pipepb.FunctionSpec{Urn: 
"c1"}},
+                                       "c2": {Spec: &pipepb.FunctionSpec{Urn: 
"c2"}},
+                                       "c3": {Spec: &pipepb.FunctionSpec{Urn: 
"c3"}},
+                                       "c4": {Spec: &pipepb.FunctionSpec{Urn: 
"c4"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0": &pipepb.Environment{Urn: "e0"},
-                                       "e1": &pipepb.Environment{Urn: "e1"},
+                                       "e0": {Urn: "e0"},
+                                       "e1": {Urn: "e1"},
                                },
                        },
                        namespace:   "daASxQwenJ",
                        transformID: "t0",
                        want: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1"},
                                                EnvironmentId: "e0@daASxQwenJ",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p2"},
@@ -416,24 +416,24 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0@daASxQwenJ", WindowingStrategyId: "w0@daASxQwenJ"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0@daASxQwenJ", WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p0": {CoderId: "c0@daASxQwenJ", 
WindowingStrategyId: "w0@daASxQwenJ"},
+                                       "p1": {CoderId: "c1@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
+                                       "p2": {CoderId: "c0@daASxQwenJ", 
WindowingStrategyId: "w1@daASxQwenJ"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0@daASxQwenJ": 
&pipepb.WindowingStrategy{WindowCoderId: "c3@daASxQwenJ", EnvironmentId: 
"e0@daASxQwenJ"},
-                                       "w1@daASxQwenJ": 
&pipepb.WindowingStrategy{WindowCoderId: "c4@daASxQwenJ", EnvironmentId: 
"e1@daASxQwenJ"},
+                                       "w0@daASxQwenJ": {WindowCoderId: 
"c3@daASxQwenJ", EnvironmentId: "e0@daASxQwenJ"},
+                                       "w1@daASxQwenJ": {WindowCoderId: 
"c4@daASxQwenJ", EnvironmentId: "e1@daASxQwenJ"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}, ComponentCoderIds: []string{"c2@daASxQwenJ"}},
-                                       "c1@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
-                                       "c2@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
-                                       "c3@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
-                                       "c4@daASxQwenJ": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
+                                       "c0@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c0"}, ComponentCoderIds: []string{"c2@daASxQwenJ"}},
+                                       "c1@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
+                                       "c2@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c2"}},
+                                       "c3@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c3"}},
+                                       "c4@daASxQwenJ": {Spec: 
&pipepb.FunctionSpec{Urn: "c4"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0@daASxQwenJ": 
&pipepb.Environment{Urn: "e0"},
-                                       "e1@daASxQwenJ": 
&pipepb.Environment{Urn: "e1"},
+                                       "e0@daASxQwenJ": {Urn: "e0"},
+                                       "e1@daASxQwenJ": {Urn: "e1"},
                                },
                        },
                },
@@ -441,13 +441,13 @@ func TestAddNamespace(t *testing.T) {
                        name: "[Consistency] Missing EnvironmentID",
                        init: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p2"},
@@ -455,21 +455,21 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w0"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1", WindowingStrategyId: "w1"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w0"},
+                                       "p1": {CoderId: "c1", 
WindowingStrategyId: "w1"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0": 
&pipepb.WindowingStrategy{WindowCoderId: "c3", EnvironmentId: "e0"},
-                                       "w1": 
&pipepb.WindowingStrategy{WindowCoderId: "c4", EnvironmentId: "e1"},
+                                       "w0": {WindowCoderId: "c3", 
EnvironmentId: "e0"},
+                                       "w1": {WindowCoderId: "c4", 
EnvironmentId: "e1"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
-                                       "c1": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
+                                       "c0": {Spec: &pipepb.FunctionSpec{Urn: 
"c0"}},
+                                       "c1": {Spec: &pipepb.FunctionSpec{Urn: 
"c1"}},
                                },
                                Environments: map[string]*pipepb.Environment{
                                        // Missing "e0"
-                                       "e1": &pipepb.Environment{Urn: "e1"},
+                                       "e1": {Urn: "e1"},
                                },
                        },
                        namespace:   "daASxQwenJ",
@@ -480,13 +480,13 @@ func TestAddNamespace(t *testing.T) {
                        name: "[Consistency] Missing WindowingStrategyID",
                        init: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p2"},
@@ -494,21 +494,21 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w0"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1", WindowingStrategyId: "w1"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w0"},
+                                       "p1": {CoderId: "c1", 
WindowingStrategyId: "w1"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
                                        // Missing w0
-                                       "w1": 
&pipepb.WindowingStrategy{WindowCoderId: "c4", EnvironmentId: "e1"},
+                                       "w1": {WindowCoderId: "c4", 
EnvironmentId: "e1"},
                                },
                                Coders: map[string]*pipepb.Coder{
-                                       "c0": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c0"}},
-                                       "c1": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
+                                       "c0": {Spec: &pipepb.FunctionSpec{Urn: 
"c0"}},
+                                       "c1": {Spec: &pipepb.FunctionSpec{Urn: 
"c1"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0": &pipepb.Environment{Urn: "e0"},
-                                       "e1": &pipepb.Environment{Urn: "e1"},
+                                       "e0": {Urn: "e0"},
+                                       "e1": {Urn: "e1"},
                                },
                        },
                        namespace:   "daASxQwenJ",
@@ -519,13 +519,13 @@ func TestAddNamespace(t *testing.T) {
                        name: "[Consistency] Missing CoderID",
                        init: &pipepb.Components{
                                Transforms: map[string]*pipepb.PTransform{
-                                       "t0": &pipepb.PTransform{
+                                       "t0": {
                                                UniqueName:    "t0",
                                                Inputs:        
map[string]string{"t0i0": "p0"},
                                                Outputs:       
map[string]string{"t0o0": "p1"},
                                                EnvironmentId: "e0",
                                        },
-                                       "t1": &pipepb.PTransform{
+                                       "t1": {
                                                UniqueName:    "t1",
                                                Inputs:        
map[string]string{"t1i0": "p1"},
                                                Outputs:       
map[string]string{"t1o0": "p2"},
@@ -533,21 +533,21 @@ func TestAddNamespace(t *testing.T) {
                                        },
                                },
                                Pcollections: map[string]*pipepb.PCollection{
-                                       "p0": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w0"},
-                                       "p1": &pipepb.PCollection{CoderId: 
"c1", WindowingStrategyId: "w1"},
-                                       "p2": &pipepb.PCollection{CoderId: 
"c0", WindowingStrategyId: "w1"},
+                                       "p0": {CoderId: "c0", 
WindowingStrategyId: "w0"},
+                                       "p1": {CoderId: "c1", 
WindowingStrategyId: "w1"},
+                                       "p2": {CoderId: "c0", 
WindowingStrategyId: "w1"},
                                },
                                WindowingStrategies: 
map[string]*pipepb.WindowingStrategy{
-                                       "w0": 
&pipepb.WindowingStrategy{WindowCoderId: "c3", EnvironmentId: "e0"},
-                                       "w1": 
&pipepb.WindowingStrategy{WindowCoderId: "c4", EnvironmentId: "e1"},
+                                       "w0": {WindowCoderId: "c3", 
EnvironmentId: "e0"},
+                                       "w1": {WindowCoderId: "c4", 
EnvironmentId: "e1"},
                                },
                                Coders: map[string]*pipepb.Coder{
                                        // Missing c0
-                                       "c1": &pipepb.Coder{Spec: 
&pipepb.FunctionSpec{Urn: "c1"}},
+                                       "c1": {Spec: &pipepb.FunctionSpec{Urn: 
"c1"}},
                                },
                                Environments: map[string]*pipepb.Environment{
-                                       "e0": &pipepb.Environment{Urn: "e0"},
-                                       "e1": &pipepb.Environment{Urn: "e1"},
+                                       "e0": {Urn: "e0"},
+                                       "e1": {Urn: "e1"},
                                },
                        },
                        namespace:   "daASxQwenJ",

Reply via email to