/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/benchmarks_test.go

https://gitlab.com/voxxit/gogeoip2 · Go · 163 lines · 145 code · 18 blank · 0 comment · 5 complexity · 3603ff5cdbf9b58236894e783ec3cf5c MD5 · raw file 

    

  1. package validator
    2. 

  2. 

  3. import "testing"
    4. 

  4. 

  5. func BenchmarkValidateField(b *testing.B) {
    6. 

  6. 	for n := 0; n < b.N; n++ {
    7. 

  7. 		validate.Field("1", "len=1")
    8. 

  8. 	}
    9. 

  9. }
    10. 

  10. 

  11. func BenchmarkValidateStructSimple(b *testing.B) {
    12. 

  12. 

  13. 	type Foo struct {
    14. 

  14. 		StringValue string `validate:"min=5,max=10"`
    15. 

  15. 		IntValue    int    `validate:"min=5,max=10"`
    16. 

  16. 	}
    17. 

  17. 

  18. 	validFoo := &Foo{StringValue: "Foobar", IntValue: 7}
    19. 

  19. 	invalidFoo := &Foo{StringValue: "Fo", IntValue: 3}
    20. 

  20. 

  21. 	for n := 0; n < b.N; n++ {
    22. 

  22. 		validate.Struct(validFoo)
    23. 

  23. 		validate.Struct(invalidFoo)
    24. 

  24. 	}
    25. 

  25. }
    26. 

  26. 

  27. func BenchmarkTemplateParallelSimple(b *testing.B) {
    28. 

  28. 

  29. 	type Foo struct {
    30. 

  30. 		StringValue string `validate:"min=5,max=10"`
    31. 

  31. 		IntValue    int    `validate:"min=5,max=10"`
    32. 

  32. 	}
    33. 

  33. 

  34. 	validFoo := &Foo{StringValue: "Foobar", IntValue: 7}
    35. 

  35. 	invalidFoo := &Foo{StringValue: "Fo", IntValue: 3}
    36. 

  36. 

  37. 	b.RunParallel(func(pb *testing.PB) {
    38. 

  38. 		for pb.Next() {
    39. 

  39. 			validate.Struct(validFoo)
    40. 

  40. 			validate.Struct(invalidFoo)
    41. 

  41. 		}
    42. 

  42. 	})
    43. 

  43. }
    44. 

  44. 

  45. func BenchmarkValidateStructLarge(b *testing.B) {
    46. 

  46. 

  47. 	tFail := &TestString{
    48. 

  48. 		Required:  "",
    49. 

  49. 		Len:       "",
    50. 

  50. 		Min:       "",
    51. 

  51. 		Max:       "12345678901",
    52. 

  52. 		MinMax:    "",
    53. 

  53. 		Lt:        "0123456789",
    54. 

  54. 		Lte:       "01234567890",
    55. 

  55. 		Gt:        "1",
    56. 

  56. 		Gte:       "1",
    57. 

  57. 		OmitEmpty: "12345678901",
    58. 

  58. 		Sub: &SubTest{
    59. 

  59. 			Test: "",
    60. 

  60. 		},
    61. 

  61. 		Anonymous: struct {
    62. 

  62. 			A string `validate:"required"`
    63. 

  63. 		}{
    64. 

  64. 			A: "",
    65. 

  65. 		},
    66. 

  66. 		Iface: &Impl{
    67. 

  67. 			F: "12",
    68. 

  68. 		},
    69. 

  69. 	}
    70. 

  70. 

  71. 	tSuccess := &TestString{
    72. 

  72. 		Required:  "Required",
    73. 

  73. 		Len:       "length==10",
    74. 

  74. 		Min:       "min=1",
    75. 

  75. 		Max:       "1234567890",
    76. 

  76. 		MinMax:    "12345",
    77. 

  77. 		Lt:        "012345678",
    78. 

  78. 		Lte:       "0123456789",
    79. 

  79. 		Gt:        "01234567890",
    80. 

  80. 		Gte:       "0123456789",
    81. 

  81. 		OmitEmpty: "",
    82. 

  82. 		Sub: &SubTest{
    83. 

  83. 			Test: "1",
    84. 

  84. 		},
    85. 

  85. 		SubIgnore: &SubTest{
    86. 

  86. 			Test: "",
    87. 

  87. 		},
    88. 

  88. 		Anonymous: struct {
    89. 

  89. 			A string `validate:"required"`
    90. 

  90. 		}{
    91. 

  91. 			A: "1",
    92. 

  92. 		},
    93. 

  93. 		Iface: &Impl{
    94. 

  94. 			F: "123",
    95. 

  95. 		},
    96. 

  96. 	}
    97. 

  97. 

  98. 	for n := 0; n < b.N; n++ {
    99. 

  99. 		validate.Struct(tSuccess)
    100. 

  100. 		validate.Struct(tFail)
    101. 

  101. 	}
    102. 

  102. }
    103. 

  103. 

  104. func BenchmarkTemplateParallelLarge(b *testing.B) {
    105. 

  105. 

  106. 	tFail := &TestString{
    107. 

  107. 		Required:  "",
    108. 

  108. 		Len:       "",
    109. 

  109. 		Min:       "",
    110. 

  110. 		Max:       "12345678901",
    111. 

  111. 		MinMax:    "",
    112. 

  112. 		Lt:        "0123456789",
    113. 

  113. 		Lte:       "01234567890",
    114. 

  114. 		Gt:        "1",
    115. 

  115. 		Gte:       "1",
    116. 

  116. 		OmitEmpty: "12345678901",
    117. 

  117. 		Sub: &SubTest{
    118. 

  118. 			Test: "",
    119. 

  119. 		},
    120. 

  120. 		Anonymous: struct {
    121. 

  121. 			A string `validate:"required"`
    122. 

  122. 		}{
    123. 

  123. 			A: "",
    124. 

  124. 		},
    125. 

  125. 		Iface: &Impl{
    126. 

  126. 			F: "12",
    127. 

  127. 		},
    128. 

  128. 	}
    129. 

  129. 

  130. 	tSuccess := &TestString{
    131. 

  131. 		Required:  "Required",
    132. 

  132. 		Len:       "length==10",
    133. 

  133. 		Min:       "min=1",
    134. 

  134. 		Max:       "1234567890",
    135. 

  135. 		MinMax:    "12345",
    136. 

  136. 		Lt:        "012345678",
    137. 

  137. 		Lte:       "0123456789",
    138. 

  138. 		Gt:        "01234567890",
    139. 

  139. 		Gte:       "0123456789",
    140. 

  140. 		OmitEmpty: "",
    141. 

  141. 		Sub: &SubTest{
    142. 

  142. 			Test: "1",
    143. 

  143. 		},
    144. 

  144. 		SubIgnore: &SubTest{
    145. 

  145. 			Test: "",
    146. 

  146. 		},
    147. 

  147. 		Anonymous: struct {
    148. 

  148. 			A string `validate:"required"`
    149. 

  149. 		}{
    150. 

  150. 			A: "1",
    151. 

  151. 		},
    152. 

  152. 		Iface: &Impl{
    153. 

  153. 			F: "123",
    154. 

  154. 		},
    155. 

  155. 	}
    156. 

  156. 

  157. 	b.RunParallel(func(pb *testing.PB) {
    158. 

  158. 		for pb.Next() {
    159. 

  159. 			validate.Struct(tSuccess)
    160. 

  160. 			validate.Struct(tFail)
    161. 

  161. 		}
    162. 

  162. 	})
    163. 

  163. }
    164.