github.com/vkolev/form@v1.2.1/benchmarks/gorilla_scheme_test.go (about)

     1  package benchmarks
     2  
     3  import (
     4  	"net/url"
     5  	"testing"
     6  
     7  	"github.com/gorilla/schema"
     8  )
     9  
    10  // Simple Benchmarks
    11  
    12  func BenchmarkSimpleUserStructGorilla(b *testing.B) {
    13  
    14  	values := getUserStructValues()
    15  	decoder := schema.NewDecoder()
    16  	decoder.IgnoreUnknownKeys(true)
    17  	var err error
    18  	b.ReportAllocs()
    19  	for n := 0; n < b.N; n++ {
    20  		var test User
    21  		if err = decoder.Decode(&test, values); err != nil {
    22  			b.Error(err)
    23  		}
    24  	}
    25  }
    26  
    27  func BenchmarkSimpleUserStructGorillaParallel(b *testing.B) {
    28  
    29  	values := getUserStructValues()
    30  	decoder := schema.NewDecoder()
    31  	decoder.IgnoreUnknownKeys(true)
    32  	var err error
    33  
    34  	b.ReportAllocs()
    35  	b.RunParallel(func(pb *testing.PB) {
    36  		for pb.Next() {
    37  			var test User
    38  			if err = decoder.Decode(&test, values); err != nil {
    39  				b.Error(err)
    40  			}
    41  		}
    42  	})
    43  }
    44  
    45  // Primitives ALL types
    46  
    47  func BenchmarkPrimitivesStructAllPrimitivesTypesGorilla(b *testing.B) {
    48  	values := getPrimitivesStructValues()
    49  	decoder := schema.NewDecoder()
    50  	decoder.IgnoreUnknownKeys(true)
    51  	var err error
    52  
    53  	b.ReportAllocs()
    54  	for n := 0; n < b.N; n++ {
    55  		var test PrimitivesStruct
    56  		if err = decoder.Decode(&test, values); err != nil {
    57  			b.Error(err)
    58  		}
    59  	}
    60  }
    61  
    62  func BenchmarkPrimitivesStructAllPrimitivesTypesGorillaParallel(b *testing.B) {
    63  	values := getPrimitivesStructValues()
    64  	decoder := schema.NewDecoder()
    65  	decoder.IgnoreUnknownKeys(true)
    66  	var err error
    67  
    68  	b.ReportAllocs()
    69  	b.RunParallel(func(pb *testing.PB) {
    70  		for pb.Next() {
    71  			var test PrimitivesStruct
    72  			if err = decoder.Decode(&test, values); err != nil {
    73  				b.Error(err)
    74  			}
    75  		}
    76  	})
    77  }
    78  
    79  // Complex Array ALL types
    80  
    81  func BenchmarkComplexArrayStructAllTypesGorilla(b *testing.B) {
    82  	values := getComplexArrayStructValues()
    83  	decoder := schema.NewDecoder()
    84  	decoder.IgnoreUnknownKeys(true)
    85  	var err error
    86  
    87  	b.ReportAllocs()
    88  	for n := 0; n < b.N; n++ {
    89  		var test ComplexArrayStruct
    90  		if err = decoder.Decode(&test, values); err != nil {
    91  			b.Error(err)
    92  		}
    93  	}
    94  }
    95  
    96  func BenchmarkComplexArrayStructAllTypesGorillaParallel(b *testing.B) {
    97  	values := getComplexArrayStructValues()
    98  	decoder := schema.NewDecoder()
    99  	decoder.IgnoreUnknownKeys(true)
   100  	var err error
   101  
   102  	b.ReportAllocs()
   103  	b.RunParallel(func(pb *testing.PB) {
   104  		for pb.Next() {
   105  			var test ComplexArrayStruct
   106  			if err = decoder.Decode(&test, values); err != nil {
   107  				b.Error(err)
   108  			}
   109  		}
   110  	})
   111  }
   112  
   113  // Complex Map ALL types
   114  
   115  func BenchmarkComplexMapStructAllTypesGorilla(b *testing.B) {
   116  	b.Log("Gorilla does not support map parsing at this time")
   117  	b.SkipNow()
   118  }
   119  
   120  func BenchmarkComplexMapStructAllTypesGorillaParallel(b *testing.B) {
   121  	b.Log("Gorilla does not support map parsing at this time")
   122  	b.SkipNow()
   123  }
   124  
   125  // NestedStruct Benchmarks
   126  
   127  func getNestedStructValuesGorilla() url.Values {
   128  	return url.Values{
   129  		// Nested Field
   130  		"Value": []string{"value"},
   131  		// Nested Array
   132  		"NestedArray.0.Value": []string{"value"},
   133  		"NestedArray.1.Value": []string{"value"},
   134  		// Nested Array Ptr
   135  		"NestedPtrArray.0.Value": []string{"value"},
   136  		"NestedPtrArray.1.Value": []string{"value"},
   137  		// Nested 2
   138  		"Nested2.Value":         []string{"value"},
   139  		"Nested2.Nested2.Value": []string{"value"},
   140  	}
   141  }
   142  
   143  func BenchmarkArrayMapNestedStructGorilla(b *testing.B) {
   144  
   145  	values := getNestedStructValuesGorilla()
   146  	decoder := schema.NewDecoder()
   147  	decoder.IgnoreUnknownKeys(true)
   148  	var err error
   149  	b.ReportAllocs()
   150  	for n := 0; n < b.N; n++ {
   151  		var test NestedStruct
   152  		if err = decoder.Decode(&test, values); err != nil {
   153  			b.Error(err)
   154  		}
   155  	}
   156  }
   157  
   158  func BenchmarkArrayMapNestedStructGorillaParallel(b *testing.B) {
   159  
   160  	values := getNestedStructValuesGorilla()
   161  	decoder := schema.NewDecoder()
   162  	decoder.IgnoreUnknownKeys(true)
   163  	var err error
   164  
   165  	b.ReportAllocs()
   166  	b.RunParallel(func(pb *testing.PB) {
   167  		for pb.Next() {
   168  			var test NestedStruct
   169  			if err = decoder.Decode(&test, values); err != nil {
   170  				b.Error(err)
   171  			}
   172  		}
   173  	})
   174  }