vendor gotest.tools/gotestsum

2019-07-31 15:23:52 -04:00 · 2019-07-31 15:23:52 -04:00 · bd2dc5e5a2
commit bd2dc5e5a2
parent 93c02e164f
81 changed files with 5469 additions and 698 deletions
--- a/Godeps/LICENSES
+++ b/Godeps/LICENSES
@ -6030,6 +6030,34 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ================================================================================
 ================================================================================
 = vendor/github.com/fatih/color licensed under: =
 The MIT License (MIT)
 Copyright (c) 2013 Fatih Arslan
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
 the Software without restriction, including without limitation the rights to
 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 the Software, and to permit persons to whom the Software is furnished to do so,
 subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 = vendor/github.com/fatih/color/LICENSE.md 316e6d590bdcde7993fb175662c0dd5a
 ================================================================================
 ================================================================================
 = vendor/github.com/fsnotify/fsnotify licensed under: =
@ -11950,34 +11978,6 @@ SOFTWARE.
 ================================================================================
 ================================================================================
 = vendor/github.com/jstemmer/go-junit-report licensed under: =
 Copyright (c) 2012 Joel Stemmer
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 = vendor/github.com/jstemmer/go-junit-report/LICENSE 5d54de929d5bc244d21d8d4d91a6ac64
 ================================================================================
 ================================================================================
 = vendor/github.com/karrick/godirwalk licensed under: =
@ -12396,6 +12396,52 @@ SOFTWARE.
 ================================================================================
 ================================================================================
 = vendor/github.com/mattn/go-colorable licensed under: =
 The MIT License (MIT)
 Copyright (c) 2016 Yasuhiro Matsumoto
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 = vendor/github.com/mattn/go-colorable/LICENSE 24ce168f90aec2456a73de1839037245
 ================================================================================
 ================================================================================
 = vendor/github.com/mattn/go-isatty licensed under: =
 Copyright (c) Yasuhiro MATSUMOTO <mattn.jp@gmail.com>
 MIT License (Expat)
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 = vendor/github.com/mattn/go-isatty/LICENSE f509beadd5a11227c27b5d2ad6c9f2c6
 ================================================================================
 ================================================================================
 = vendor/github.com/mattn/go-shellwords licensed under: =
@ -18338,6 +18384,41 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ================================================================================
 ================================================================================
 = vendor/golang.org/x/sync licensed under: =
 Copyright (c) 2009 The Go Authors. All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
   * Redistributions of source code must retain the above copyright
 notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
   * Neither the name of Google Inc. nor the names of its
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 = vendor/golang.org/x/sync/LICENSE 5d4950ecb7b26d2c5e4e7b4e0dd74707
 ================================================================================
 ================================================================================
 = vendor/golang.org/x/sys licensed under: =
@ -19797,6 +19878,237 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ================================================================================
 ================================================================================
 = vendor/gotest.tools licensed under: =
 Copyright 2018 gotest.tools authors
 Licensed 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.
 = vendor/gotest.tools/LICENSE 26d13e18e6e60338287c11c73cc80ff5
 ================================================================================
 ================================================================================
 = vendor/gotest.tools/gotestsum licensed under: =
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   APPENDIX: How to apply the Apache License to your work.
      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.
   Copyright [yyyy] [name of copyright owner]
   Licensed 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.
 = vendor/gotest.tools/gotestsum/LICENSE 3b83ef96387f14655fc854ddc3c6bd57
 ================================================================================
 ================================================================================
 = vendor/k8s.io/gengo licensed under: =
--- a/go.mod
+++ b/go.mod
@ -84,7 +84,6 @@ require (
 	github.com/heketi/utils v0.0.0-20170317161834-435bc5bdfa64 // indirect
 	github.com/jonboulle/clockwork v0.1.0
 	github.com/json-iterator/go v1.1.6
 	github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024
 	github.com/karrick/godirwalk v1.7.5 // indirect
 	github.com/libopenstorage/openstorage v1.0.0
 	github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de
@ -148,6 +147,8 @@ require (
 	gopkg.in/gcfg.v1 v1.2.0
 	gopkg.in/square/go-jose.v2 v2.2.2
 	gopkg.in/yaml.v2 v2.2.2
 	gotest.tools v2.2.0+incompatible
 	gotest.tools/gotestsum v0.3.5
 	k8s.io/api v0.0.0
 	k8s.io/apiextensions-apiserver v0.0.0
 	k8s.io/apimachinery v0.0.0
@ -251,6 +252,7 @@ replace (
 	github.com/evanphx/json-patch => github.com/evanphx/json-patch v4.2.0+incompatible
 	github.com/exponent-io/jsonpath => github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d
 	github.com/fatih/camelcase => github.com/fatih/camelcase v1.0.0
 	github.com/fatih/color => github.com/fatih/color v1.6.0
 	github.com/flynn/go-shlex => github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568
 	github.com/fsnotify/fsnotify => github.com/fsnotify/fsnotify v1.4.7
 	github.com/ghodss/yaml => github.com/ghodss/yaml v0.0.0-20180820084758-c7ce16629ff4
@ -307,7 +309,6 @@ replace (
 	github.com/jmespath/go-jmespath => github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af
 	github.com/jonboulle/clockwork => github.com/jonboulle/clockwork v0.1.0
 	github.com/json-iterator/go => github.com/json-iterator/go v1.1.6
 	github.com/jstemmer/go-junit-report => github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024
 	github.com/jtolds/gls => github.com/jtolds/gls v4.20.0+incompatible
 	github.com/karrick/godirwalk => github.com/karrick/godirwalk v1.7.5
 	github.com/kisielk/errcheck => github.com/kisielk/errcheck v1.2.0
@ -330,6 +331,8 @@ replace (
 	github.com/mailru/easyjson => github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63
 	github.com/marstr/guid => github.com/marstr/guid v0.0.0-20170427235115-8bdf7d1a087c
 	github.com/marten-seemann/qtls => github.com/marten-seemann/qtls v0.2.3
 	github.com/mattn/go-colorable => github.com/mattn/go-colorable v0.0.9
 	github.com/mattn/go-isatty => github.com/mattn/go-isatty v0.0.3
 	github.com/mattn/go-shellwords => github.com/mattn/go-shellwords v1.0.5
 	github.com/matttproud/golang_protobuf_extensions => github.com/matttproud/golang_protobuf_extensions v1.0.1
 	github.com/mesos/mesos-go => github.com/mesos/mesos-go v0.0.9
@ -420,9 +423,11 @@ replace (
 	google.golang.org/appengine => google.golang.org/appengine v1.5.0
 	google.golang.org/genproto => google.golang.org/genproto v0.0.0-20170731182057-09f6ed296fc6
 	google.golang.org/grpc => google.golang.org/grpc v1.13.0
 	gopkg.in/airbrake/gobrake.v2 => gopkg.in/airbrake/gobrake.v2 v2.0.9
 	gopkg.in/check.v1 => gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127
 	gopkg.in/fsnotify.v1 => gopkg.in/fsnotify.v1 v1.4.7
 	gopkg.in/gcfg.v1 => gopkg.in/gcfg.v1 v1.2.0
 	gopkg.in/gemnasium/logrus-airbrake-hook.v2 => gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2
 	gopkg.in/inf.v0 => gopkg.in/inf.v0 v0.9.0
 	gopkg.in/mcuadros/go-syslog.v2 => gopkg.in/mcuadros/go-syslog.v2 v2.2.1
 	gopkg.in/natefinch/lumberjack.v2 => gopkg.in/natefinch/lumberjack.v2 v2.0.0
@ -431,6 +436,7 @@ replace (
 	gopkg.in/warnings.v0 => gopkg.in/warnings.v0 v0.1.1
 	gopkg.in/yaml.v2 => gopkg.in/yaml.v2 v2.2.2
 	gotest.tools => gotest.tools v2.2.0+incompatible
 	gotest.tools/gotestsum => gotest.tools/gotestsum v0.3.5
 	k8s.io/api => ./staging/src/k8s.io/api
 	k8s.io/apiextensions-apiserver => ./staging/src/k8s.io/apiextensions-apiserver
 	k8s.io/apimachinery => ./staging/src/k8s.io/apimachinery
--- a/go.sum
+++ b/go.sum
@ -131,6 +131,8 @@ github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d h1:105gxyaGwC
 github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d/go.mod h1:ZZMPRZwes7CROmyNKgQzC3XPs6L/G2EJLHddWejkmf4=
 github.com/fatih/camelcase v1.0.0 h1:hxNvNX/xYBp0ovncs8WyWZrOrpBNub/JfaMvbURyft8=
 github.com/fatih/camelcase v1.0.0/go.mod h1:yN2Sb0lFhZJUdVvtELVWefmrXpuZESvPmqwoZc+/fpc=
 github.com/fatih/color v1.6.0 h1:66qjqZk8kalYAvDRtM1AdAJQI0tj4Wrue3Eq3B3pmFU=
 github.com/fatih/color v1.6.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
@ -239,8 +241,6 @@ github.com/jonboulle/clockwork v0.1.0 h1:VKV+ZcuP6l3yW9doeqz6ziZGgcynBVQO+obU0+0
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/json-iterator/go v1.1.6 h1:MrUvLMLTMxbqFJ9kzlvat/rYZqZnW3u4wkLzWTaFwKs=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024 h1:rBMNdlhTLzJjJSDIjNEXX1Pz3Hmwmz91v+zycvx9PJc=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/karrick/godirwalk v1.7.5 h1:VbzFqwXwNbAZoA6W5odrLr+hKK197CcENcPh6E/gJ0M=
@ -275,6 +275,10 @@ github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN
 github.com/marstr/guid v0.0.0-20170427235115-8bdf7d1a087c h1:N7uWGS2fTwH/4BwxbHiJZNAFTSJ5yPU0emHsQWvkxEY=
 github.com/marstr/guid v0.0.0-20170427235115-8bdf7d1a087c/go.mod h1:74gB1z2wpxxInTG6yaqA7KrtM0NZ+RbrcqDvYHefzho=
 github.com/marten-seemann/qtls v0.2.3/go.mod h1:xzjG7avBwGGbdZ8dTGxlBnLArsVKLvwmjgmPuiQEcYk=
 github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-shellwords v1.0.5 h1:JhhFTIOslh5ZsPrpa3Wdg8bF0WI3b44EMblmU9wIsXc=
 github.com/mattn/go-shellwords v1.0.5/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o=
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
@ -446,12 +450,14 @@ google.golang.org/genproto v0.0.0-20170731182057-09f6ed296fc6 h1:72GtwBPfq6av9X0
 google.golang.org/genproto v0.0.0-20170731182057-09f6ed296fc6/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/grpc v1.13.0 h1:bHIbVsCwmvbArgCJmLdgOdHFXlKqTOVjbibbS19cXHc=
 google.golang.org/grpc v1.13.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/gcfg.v1 v1.2.0 h1:0HIbH907iBTAntm+88IJV2qmJALDAh8sPekI9Vc1fm0=
 gopkg.in/gcfg.v1 v1.2.0/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o=
 gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
 gopkg.in/inf.v0 v0.9.0 h1:3zYtXIO92bvsdS3ggAdA8Gb4Azj0YU+TVY1uGYNFA8o=
 gopkg.in/inf.v0 v0.9.0/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
 gopkg.in/mcuadros/go-syslog.v2 v2.2.1/go.mod h1:l5LPIyOOyIdQquNg+oU6Z3524YwrcqEm0aKH+5zpt2U=
@ -467,6 +473,8 @@ gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 gotest.tools/gotestsum v0.3.5 h1:VePOWRsuWFYpfp/G8mbmOZKxO5T3501SEGQRUdvq7h0=
 gotest.tools/gotestsum v0.3.5/go.mod h1:Mnf3e5FUzXbkCfynWBGOwLssY7gTQgCHObK9tMpAriY=
 k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6 h1:4s3/R4+OYYYUKptXPhZKjQ04WJ6EhQQVFdjOFvCazDk=
 k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
 k8s.io/heapster v1.2.0-beta.1 h1:lUsE/AHOMHpi3MLlBEkaU8Esxm5QhdyCrv1o7ot0s84=
--- a/vendor/BUILD
+++ b/vendor/BUILD
@ -181,6 +181,7 @@ filegroup(
        "//vendor/github.com/evanphx/json-patch:all-srcs",
        "//vendor/github.com/exponent-io/jsonpath:all-srcs",
        "//vendor/github.com/fatih/camelcase:all-srcs",
        "//vendor/github.com/fatih/color:all-srcs",
        "//vendor/github.com/fsnotify/fsnotify:all-srcs",
        "//vendor/github.com/ghodss/yaml:all-srcs",
        "//vendor/github.com/globalsign/mgo/bson:all-srcs",
@ -274,7 +275,6 @@ filegroup(
        "//vendor/github.com/jmespath/go-jmespath:all-srcs",
        "//vendor/github.com/jonboulle/clockwork:all-srcs",
        "//vendor/github.com/json-iterator/go:all-srcs",
        "//vendor/github.com/jstemmer/go-junit-report:all-srcs",
        "//vendor/github.com/karrick/godirwalk:all-srcs",
        "//vendor/github.com/konsorten/go-windows-terminal-sequences:all-srcs",
        "//vendor/github.com/libopenstorage/openstorage/api:all-srcs",
@ -288,6 +288,8 @@ filegroup(
        "//vendor/github.com/mailru/easyjson/jlexer:all-srcs",
        "//vendor/github.com/mailru/easyjson/jwriter:all-srcs",
        "//vendor/github.com/marstr/guid:all-srcs",
        "//vendor/github.com/mattn/go-colorable:all-srcs",
        "//vendor/github.com/mattn/go-isatty:all-srcs",
        "//vendor/github.com/mattn/go-shellwords:all-srcs",
        "//vendor/github.com/matttproud/golang_protobuf_extensions/pbutil:all-srcs",
        "//vendor/github.com/miekg/dns:all-srcs",
@ -382,6 +384,7 @@ filegroup(
        "//vendor/golang.org/x/net/trace:all-srcs",
        "//vendor/golang.org/x/net/websocket:all-srcs",
        "//vendor/golang.org/x/oauth2:all-srcs",
        "//vendor/golang.org/x/sync/errgroup:all-srcs",
        "//vendor/golang.org/x/sys/unix:all-srcs",
        "//vendor/golang.org/x/sys/windows:all-srcs",
        "//vendor/golang.org/x/text/encoding:all-srcs",
@ -442,6 +445,7 @@ filegroup(
        "//vendor/gopkg.in/tomb.v1:all-srcs",
        "//vendor/gopkg.in/warnings.v0:all-srcs",
        "//vendor/gopkg.in/yaml.v2:all-srcs",
        "//vendor/gotest.tools:all-srcs",
        "//vendor/k8s.io/gengo/args:all-srcs",
        "//vendor/k8s.io/gengo/examples/deepcopy-gen/generators:all-srcs",
        "//vendor/k8s.io/gengo/examples/defaulter-gen/generators:all-srcs",
--- a/vendor/github.com/fatih/color/.travis.yml
+++ b/vendor/github.com/fatih/color/.travis.yml
@ -0,0 +1,5 @@
 language: go
 go: 
 - 1.8.x
 - tip
--- a/vendor/github.com/jstemmer/go-junit-report/formatter/BUILD
+++ b/vendor/github.com/jstemmer/go-junit-report/formatter/BUILD
@ -2,11 +2,17 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
    name = "go_default_library",
-    srcs = ["formatter.go"],
+    srcs = [
-    importmap = "k8s.io/kubernetes/vendor/github.com/jstemmer/go-junit-report/formatter",
+        "color.go",
-    importpath = "github.com/jstemmer/go-junit-report/formatter",
+        "doc.go",
    ],
    importmap = "k8s.io/kubernetes/vendor/github.com/fatih/color",
    importpath = "github.com/fatih/color",
    visibility = ["//visibility:public"],
-    deps = ["//vendor/github.com/jstemmer/go-junit-report/parser:go_default_library"],
+    deps = [
        "//vendor/github.com/mattn/go-colorable:go_default_library",
        "//vendor/github.com/mattn/go-isatty:go_default_library",
    ],
 )
 filegroup(
--- a/vendor/github.com/fatih/color/Gopkg.lock
+++ b/vendor/github.com/fatih/color/Gopkg.lock
@ -0,0 +1,27 @@
 # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 [[projects]]
  name = "github.com/mattn/go-colorable"
  packages = ["."]
  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
  version = "v0.0.9"
 [[projects]]
  name = "github.com/mattn/go-isatty"
  packages = ["."]
  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
  version = "v0.0.3"
 [[projects]]
  branch = "master"
  name = "golang.org/x/sys"
  packages = ["unix"]
  revision = "37707fdb30a5b38865cfb95e5aab41707daec7fd"
 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
  inputs-digest = "e8a50671c3cb93ea935bf210b1cd20702876b9d9226129be581ef646d1565cdc"
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/vendor/github.com/fatih/color/Gopkg.toml
+++ b/vendor/github.com/fatih/color/Gopkg.toml
@ -0,0 +1,30 @@
 # Gopkg.toml example
 #
 # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
 # for detailed Gopkg.toml documentation.
 #
 # required = ["github.com/user/thing/cmd/thing"]
 # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
 #
 # [[constraint]]
 #   name = "github.com/user/project"
 #   version = "1.0.0"
 #
 # [[constraint]]
 #   name = "github.com/user/project2"
 #   branch = "dev"
 #   source = "github.com/myfork/project2"
 #
 # [[override]]
 #  name = "github.com/x/y"
 #  version = "2.4.0"
 [[constraint]]
  name = "github.com/mattn/go-colorable"
  version = "0.0.9"
 [[constraint]]
  name = "github.com/mattn/go-isatty"
  version = "0.0.3"
--- a/vendor/github.com/fatih/color/LICENSE.md
+++ b/vendor/github.com/fatih/color/LICENSE.md
@ -0,0 +1,20 @@
 The MIT License (MIT)
 Copyright (c) 2013 Fatih Arslan
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
 the Software without restriction, including without limitation the rights to
 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 the Software, and to permit persons to whom the Software is furnished to do so,
 subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/fatih/color/README.md
+++ b/vendor/github.com/fatih/color/README.md
@ -0,0 +1,179 @@
 # Color [![GoDoc](https://godoc.org/github.com/fatih/color?status.svg)](https://godoc.org/github.com/fatih/color) [![Build Status](https://img.shields.io/travis/fatih/color.svg?style=flat-square)](https://travis-ci.org/fatih/color)
 Color lets you use colorized outputs in terms of [ANSI Escape
 Codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors) in Go (Golang). It
 has support for Windows too! The API can be used in several ways, pick one that
 suits you.
 ![Color](https://i.imgur.com/c1JI0lA.png)
 ## Install
 ```bash
 go get github.com/fatih/color
 ```
 Note that the `vendor` folder is here for stability. Remove the folder if you
 already have the dependencies in your GOPATH.
 ## Examples
 ### Standard colors
 ```go
 // Print with default helper functions
 color.Cyan("Prints text in cyan.")
 // A newline will be appended automatically
 color.Blue("Prints %s in blue.", "text")
 // These are using the default foreground colors
 color.Red("We have red")
 color.Magenta("And many others ..")
 ```
 ### Mix and reuse colors
 ```go
 // Create a new color object
 c := color.New(color.FgCyan).Add(color.Underline)
 c.Println("Prints cyan text with an underline.")
 // Or just add them to New()
 d := color.New(color.FgCyan, color.Bold)
 d.Printf("This prints bold cyan %s\n", "too!.")
 // Mix up foreground and background colors, create new mixes!
 red := color.New(color.FgRed)
 boldRed := red.Add(color.Bold)
 boldRed.Println("This will print text in bold red.")
 whiteBackground := red.Add(color.BgWhite)
 whiteBackground.Println("Red text with white background.")
 ```
 ### Use your own output (io.Writer)
 ```go
 // Use your own io.Writer output
 color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
 blue := color.New(color.FgBlue)
 blue.Fprint(writer, "This will print text in blue.")
 ```
 ### Custom print functions (PrintFunc)
 ```go
 // Create a custom print function for convenience
 red := color.New(color.FgRed).PrintfFunc()
 red("Warning")
 red("Error: %s", err)
 // Mix up multiple attributes
 notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
 notice("Don't forget this...")
 ```
 ### Custom fprint functions (FprintFunc)
 ```go
 blue := color.New(FgBlue).FprintfFunc()
 blue(myWriter, "important notice: %s", stars)
 // Mix up with multiple attributes
 success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
 success(myWriter, "Don't forget this...")
 ```
 ### Insert into noncolor strings (SprintFunc)
 ```go
 // Create SprintXxx functions to mix strings with other non-colorized strings:
 yellow := color.New(color.FgYellow).SprintFunc()
 red := color.New(color.FgRed).SprintFunc()
 fmt.Printf("This is a %s and this is %s.\n", yellow("warning"), red("error"))
 info := color.New(color.FgWhite, color.BgGreen).SprintFunc()
 fmt.Printf("This %s rocks!\n", info("package"))
 // Use helper functions
 fmt.Println("This", color.RedString("warning"), "should be not neglected.")
 fmt.Printf("%v %v\n", color.GreenString("Info:"), "an important message.")
 // Windows supported too! Just don't forget to change the output to color.Output
 fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
 ```
 ### Plug into existing code
 ```go
 // Use handy standard colors
 color.Set(color.FgYellow)
 fmt.Println("Existing text will now be in yellow")
 fmt.Printf("This one %s\n", "too")
 color.Unset() // Don't forget to unset
 // You can mix up parameters
 color.Set(color.FgMagenta, color.Bold)
 defer color.Unset() // Use it in your function
 fmt.Println("All text will now be bold magenta.")
 ```
 ### Disable/Enable color
 There might be a case where you want to explicitly disable/enable color output. the 
 `go-isatty` package will automatically disable color output for non-tty output streams 
 (for example if the output were piped directly to `less`)
 `Color` has support to disable/enable colors both globally and for single color 
 definitions. For example suppose you have a CLI app and a `--no-color` bool flag. You 
 can easily disable the color output with:
 ```go
 var flagNoColor = flag.Bool("no-color", false, "Disable color output")
 if *flagNoColor {
 	color.NoColor = true // disables colorized output
 }
 ```
 It also has support for single color definitions (local). You can
 disable/enable color output on the fly:
 ```go
 c := color.New(color.FgCyan)
 c.Println("Prints cyan text")
 c.DisableColor()
 c.Println("This is printed without any color")
 c.EnableColor()
 c.Println("This prints again cyan...")
 ```
 ## Todo
 * Save/Return previous values
 * Evaluate fmt.Formatter interface
 ## Credits
 * [Fatih Arslan](https://github.com/fatih)
 * Windows support via @mattn: [colorable](https://github.com/mattn/go-colorable)
 ## License
 The MIT License (MIT) - see [`LICENSE.md`](https://github.com/fatih/color/blob/master/LICENSE.md) for more details
--- a/vendor/github.com/fatih/color/color.go
+++ b/vendor/github.com/fatih/color/color.go
@ -0,0 +1,600 @@
 package color
 import (
 	"fmt"
 	"io"
 	"os"
 	"strconv"
 	"strings"
 	"sync"
 	"github.com/mattn/go-colorable"
 	"github.com/mattn/go-isatty"
 )
 var (
 	// NoColor defines if the output is colorized or not. It's dynamically set to
 	// false or true based on the stdout's file descriptor referring to a terminal
 	// or not. This is a global option and affects all colors. For more control
 	// over each color block use the methods DisableColor() individually.
 	NoColor = os.Getenv("TERM") == "dumb" ||
 		(!isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()))
 	// Output defines the standard output of the print functions. By default
 	// os.Stdout is used.
 	Output = colorable.NewColorableStdout()
 	// colorsCache is used to reduce the count of created Color objects and
 	// allows to reuse already created objects with required Attribute.
 	colorsCache   = make(map[Attribute]*Color)
 	colorsCacheMu sync.Mutex // protects colorsCache
 )
 // Color defines a custom color object which is defined by SGR parameters.
 type Color struct {
 	params  []Attribute
 	noColor *bool
 }
 // Attribute defines a single SGR Code
 type Attribute int
 const escape = "\x1b"
 // Base attributes
 const (
 	Reset Attribute = iota
 	Bold
 	Faint
 	Italic
 	Underline
 	BlinkSlow
 	BlinkRapid
 	ReverseVideo
 	Concealed
 	CrossedOut
 )
 // Foreground text colors
 const (
 	FgBlack Attribute = iota + 30
 	FgRed
 	FgGreen
 	FgYellow
 	FgBlue
 	FgMagenta
 	FgCyan
 	FgWhite
 )
 // Foreground Hi-Intensity text colors
 const (
 	FgHiBlack Attribute = iota + 90
 	FgHiRed
 	FgHiGreen
 	FgHiYellow
 	FgHiBlue
 	FgHiMagenta
 	FgHiCyan
 	FgHiWhite
 )
 // Background text colors
 const (
 	BgBlack Attribute = iota + 40
 	BgRed
 	BgGreen
 	BgYellow
 	BgBlue
 	BgMagenta
 	BgCyan
 	BgWhite
 )
 // Background Hi-Intensity text colors
 const (
 	BgHiBlack Attribute = iota + 100
 	BgHiRed
 	BgHiGreen
 	BgHiYellow
 	BgHiBlue
 	BgHiMagenta
 	BgHiCyan
 	BgHiWhite
 )
 // New returns a newly created color object.
 func New(value ...Attribute) *Color {
 	c := &Color{params: make([]Attribute, 0)}
 	c.Add(value...)
 	return c
 }
 // Set sets the given parameters immediately. It will change the color of
 // output with the given SGR parameters until color.Unset() is called.
 func Set(p ...Attribute) *Color {
 	c := New(p...)
 	c.Set()
 	return c
 }
 // Unset resets all escape attributes and clears the output. Usually should
 // be called after Set().
 func Unset() {
 	if NoColor {
 		return
 	}
 	fmt.Fprintf(Output, "%s[%dm", escape, Reset)
 }
 // Set sets the SGR sequence.
 func (c *Color) Set() *Color {
 	if c.isNoColorSet() {
 		return c
 	}
 	fmt.Fprintf(Output, c.format())
 	return c
 }
 func (c *Color) unset() {
 	if c.isNoColorSet() {
 		return
 	}
 	Unset()
 }
 func (c *Color) setWriter(w io.Writer) *Color {
 	if c.isNoColorSet() {
 		return c
 	}
 	fmt.Fprintf(w, c.format())
 	return c
 }
 func (c *Color) unsetWriter(w io.Writer) {
 	if c.isNoColorSet() {
 		return
 	}
 	if NoColor {
 		return
 	}
 	fmt.Fprintf(w, "%s[%dm", escape, Reset)
 }
 // Add is used to chain SGR parameters. Use as many as parameters to combine
 // and create custom color objects. Example: Add(color.FgRed, color.Underline).
 func (c *Color) Add(value ...Attribute) *Color {
 	c.params = append(c.params, value...)
 	return c
 }
 func (c *Color) prepend(value Attribute) {
 	c.params = append(c.params, 0)
 	copy(c.params[1:], c.params[0:])
 	c.params[0] = value
 }
 // Fprint formats using the default formats for its operands and writes to w.
 // Spaces are added between operands when neither is a string.
 // It returns the number of bytes written and any write error encountered.
 // On Windows, users should wrap w with colorable.NewColorable() if w is of
 // type *os.File.
 func (c *Color) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
 	c.setWriter(w)
 	defer c.unsetWriter(w)
 	return fmt.Fprint(w, a...)
 }
 // Print formats using the default formats for its operands and writes to
 // standard output. Spaces are added between operands when neither is a
 // string. It returns the number of bytes written and any write error
 // encountered. This is the standard fmt.Print() method wrapped with the given
 // color.
 func (c *Color) Print(a ...interface{}) (n int, err error) {
 	c.Set()
 	defer c.unset()
 	return fmt.Fprint(Output, a...)
 }
 // Fprintf formats according to a format specifier and writes to w.
 // It returns the number of bytes written and any write error encountered.
 // On Windows, users should wrap w with colorable.NewColorable() if w is of
 // type *os.File.
 func (c *Color) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
 	c.setWriter(w)
 	defer c.unsetWriter(w)
 	return fmt.Fprintf(w, format, a...)
 }
 // Printf formats according to a format specifier and writes to standard output.
 // It returns the number of bytes written and any write error encountered.
 // This is the standard fmt.Printf() method wrapped with the given color.
 func (c *Color) Printf(format string, a ...interface{}) (n int, err error) {
 	c.Set()
 	defer c.unset()
 	return fmt.Fprintf(Output, format, a...)
 }
 // Fprintln formats using the default formats for its operands and writes to w.
 // Spaces are always added between operands and a newline is appended.
 // On Windows, users should wrap w with colorable.NewColorable() if w is of
 // type *os.File.
 func (c *Color) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
 	c.setWriter(w)
 	defer c.unsetWriter(w)
 	return fmt.Fprintln(w, a...)
 }
 // Println formats using the default formats for its operands and writes to
 // standard output. Spaces are always added between operands and a newline is
 // appended. It returns the number of bytes written and any write error
 // encountered. This is the standard fmt.Print() method wrapped with the given
 // color.
 func (c *Color) Println(a ...interface{}) (n int, err error) {
 	c.Set()
 	defer c.unset()
 	return fmt.Fprintln(Output, a...)
 }
 // Sprint is just like Print, but returns a string instead of printing it.
 func (c *Color) Sprint(a ...interface{}) string {
 	return c.wrap(fmt.Sprint(a...))
 }
 // Sprintln is just like Println, but returns a string instead of printing it.
 func (c *Color) Sprintln(a ...interface{}) string {
 	return c.wrap(fmt.Sprintln(a...))
 }
 // Sprintf is just like Printf, but returns a string instead of printing it.
 func (c *Color) Sprintf(format string, a ...interface{}) string {
 	return c.wrap(fmt.Sprintf(format, a...))
 }
 // FprintFunc returns a new function that prints the passed arguments as
 // colorized with color.Fprint().
 func (c *Color) FprintFunc() func(w io.Writer, a ...interface{}) {
 	return func(w io.Writer, a ...interface{}) {
 		c.Fprint(w, a...)
 	}
 }
 // PrintFunc returns a new function that prints the passed arguments as
 // colorized with color.Print().
 func (c *Color) PrintFunc() func(a ...interface{}) {
 	return func(a ...interface{}) {
 		c.Print(a...)
 	}
 }
 // FprintfFunc returns a new function that prints the passed arguments as
 // colorized with color.Fprintf().
 func (c *Color) FprintfFunc() func(w io.Writer, format string, a ...interface{}) {
 	return func(w io.Writer, format string, a ...interface{}) {
 		c.Fprintf(w, format, a...)
 	}
 }
 // PrintfFunc returns a new function that prints the passed arguments as
 // colorized with color.Printf().
 func (c *Color) PrintfFunc() func(format string, a ...interface{}) {
 	return func(format string, a ...interface{}) {
 		c.Printf(format, a...)
 	}
 }
 // FprintlnFunc returns a new function that prints the passed arguments as
 // colorized with color.Fprintln().
 func (c *Color) FprintlnFunc() func(w io.Writer, a ...interface{}) {
 	return func(w io.Writer, a ...interface{}) {
 		c.Fprintln(w, a...)
 	}
 }
 // PrintlnFunc returns a new function that prints the passed arguments as
 // colorized with color.Println().
 func (c *Color) PrintlnFunc() func(a ...interface{}) {
 	return func(a ...interface{}) {
 		c.Println(a...)
 	}
 }
 // SprintFunc returns a new function that returns colorized strings for the
 // given arguments with fmt.Sprint(). Useful to put into or mix into other
 // string. Windows users should use this in conjunction with color.Output, example:
 //
 //	put := New(FgYellow).SprintFunc()
 //	fmt.Fprintf(color.Output, "This is a %s", put("warning"))
 func (c *Color) SprintFunc() func(a ...interface{}) string {
 	return func(a ...interface{}) string {
 		return c.wrap(fmt.Sprint(a...))
 	}
 }
 // SprintfFunc returns a new function that returns colorized strings for the
 // given arguments with fmt.Sprintf(). Useful to put into or mix into other
 // string. Windows users should use this in conjunction with color.Output.
 func (c *Color) SprintfFunc() func(format string, a ...interface{}) string {
 	return func(format string, a ...interface{}) string {
 		return c.wrap(fmt.Sprintf(format, a...))
 	}
 }
 // SprintlnFunc returns a new function that returns colorized strings for the
 // given arguments with fmt.Sprintln(). Useful to put into or mix into other
 // string. Windows users should use this in conjunction with color.Output.
 func (c *Color) SprintlnFunc() func(a ...interface{}) string {
 	return func(a ...interface{}) string {
 		return c.wrap(fmt.Sprintln(a...))
 	}
 }
 // sequence returns a formatted SGR sequence to be plugged into a "\x1b[...m"
 // an example output might be: "1;36" -> bold cyan
 func (c *Color) sequence() string {
 	format := make([]string, len(c.params))
 	for i, v := range c.params {
 		format[i] = strconv.Itoa(int(v))
 	}
 	return strings.Join(format, ";")
 }
 // wrap wraps the s string with the colors attributes. The string is ready to
 // be printed.
 func (c *Color) wrap(s string) string {
 	if c.isNoColorSet() {
 		return s
 	}
 	return c.format() + s + c.unformat()
 }
 func (c *Color) format() string {
 	return fmt.Sprintf("%s[%sm", escape, c.sequence())
 }
 func (c *Color) unformat() string {
 	return fmt.Sprintf("%s[%dm", escape, Reset)
 }
 // DisableColor disables the color output. Useful to not change any existing
 // code and still being able to output. Can be used for flags like
 // "--no-color". To enable back use EnableColor() method.
 func (c *Color) DisableColor() {
 	c.noColor = boolPtr(true)
 }
 // EnableColor enables the color output. Use it in conjunction with
 // DisableColor(). Otherwise this method has no side effects.
 func (c *Color) EnableColor() {
 	c.noColor = boolPtr(false)
 }
 func (c *Color) isNoColorSet() bool {
 	// check first if we have user setted action
 	if c.noColor != nil {
 		return *c.noColor
 	}
 	// if not return the global option, which is disabled by default
 	return NoColor
 }
 // Equals returns a boolean value indicating whether two colors are equal.
 func (c *Color) Equals(c2 *Color) bool {
 	if len(c.params) != len(c2.params) {
 		return false
 	}
 	for _, attr := range c.params {
 		if !c2.attrExists(attr) {
 			return false
 		}
 	}
 	return true
 }
 func (c *Color) attrExists(a Attribute) bool {
 	for _, attr := range c.params {
 		if attr == a {
 			return true
 		}
 	}
 	return false
 }
 func boolPtr(v bool) *bool {
 	return &v
 }
 func getCachedColor(p Attribute) *Color {
 	colorsCacheMu.Lock()
 	defer colorsCacheMu.Unlock()
 	c, ok := colorsCache[p]
 	if !ok {
 		c = New(p)
 		colorsCache[p] = c
 	}
 	return c
 }
 func colorPrint(format string, p Attribute, a ...interface{}) {
 	c := getCachedColor(p)
 	if !strings.HasSuffix(format, "\n") {
 		format += "\n"
 	}
 	if len(a) == 0 {
 		c.Print(format)
 	} else {
 		c.Printf(format, a...)
 	}
 }
 func colorString(format string, p Attribute, a ...interface{}) string {
 	c := getCachedColor(p)
 	if len(a) == 0 {
 		return c.SprintFunc()(format)
 	}
 	return c.SprintfFunc()(format, a...)
 }
 // Black is a convenient helper function to print with black foreground. A
 // newline is appended to format by default.
 func Black(format string, a ...interface{}) { colorPrint(format, FgBlack, a...) }
 // Red is a convenient helper function to print with red foreground. A
 // newline is appended to format by default.
 func Red(format string, a ...interface{}) { colorPrint(format, FgRed, a...) }
 // Green is a convenient helper function to print with green foreground. A
 // newline is appended to format by default.
 func Green(format string, a ...interface{}) { colorPrint(format, FgGreen, a...) }
 // Yellow is a convenient helper function to print with yellow foreground.
 // A newline is appended to format by default.
 func Yellow(format string, a ...interface{}) { colorPrint(format, FgYellow, a...) }
 // Blue is a convenient helper function to print with blue foreground. A
 // newline is appended to format by default.
 func Blue(format string, a ...interface{}) { colorPrint(format, FgBlue, a...) }
 // Magenta is a convenient helper function to print with magenta foreground.
 // A newline is appended to format by default.
 func Magenta(format string, a ...interface{}) { colorPrint(format, FgMagenta, a...) }
 // Cyan is a convenient helper function to print with cyan foreground. A
 // newline is appended to format by default.
 func Cyan(format string, a ...interface{}) { colorPrint(format, FgCyan, a...) }
 // White is a convenient helper function to print with white foreground. A
 // newline is appended to format by default.
 func White(format string, a ...interface{}) { colorPrint(format, FgWhite, a...) }
 // BlackString is a convenient helper function to return a string with black
 // foreground.
 func BlackString(format string, a ...interface{}) string { return colorString(format, FgBlack, a...) }
 // RedString is a convenient helper function to return a string with red
 // foreground.
 func RedString(format string, a ...interface{}) string { return colorString(format, FgRed, a...) }
 // GreenString is a convenient helper function to return a string with green
 // foreground.
 func GreenString(format string, a ...interface{}) string { return colorString(format, FgGreen, a...) }
 // YellowString is a convenient helper function to return a string with yellow
 // foreground.
 func YellowString(format string, a ...interface{}) string { return colorString(format, FgYellow, a...) }
 // BlueString is a convenient helper function to return a string with blue
 // foreground.
 func BlueString(format string, a ...interface{}) string { return colorString(format, FgBlue, a...) }
 // MagentaString is a convenient helper function to return a string with magenta
 // foreground.
 func MagentaString(format string, a ...interface{}) string {
 	return colorString(format, FgMagenta, a...)
 }
 // CyanString is a convenient helper function to return a string with cyan
 // foreground.
 func CyanString(format string, a ...interface{}) string { return colorString(format, FgCyan, a...) }
 // WhiteString is a convenient helper function to return a string with white
 // foreground.
 func WhiteString(format string, a ...interface{}) string { return colorString(format, FgWhite, a...) }
 // HiBlack is a convenient helper function to print with hi-intensity black foreground. A
 // newline is appended to format by default.
 func HiBlack(format string, a ...interface{}) { colorPrint(format, FgHiBlack, a...) }
 // HiRed is a convenient helper function to print with hi-intensity red foreground. A
 // newline is appended to format by default.
 func HiRed(format string, a ...interface{}) { colorPrint(format, FgHiRed, a...) }
 // HiGreen is a convenient helper function to print with hi-intensity green foreground. A
 // newline is appended to format by default.
 func HiGreen(format string, a ...interface{}) { colorPrint(format, FgHiGreen, a...) }
 // HiYellow is a convenient helper function to print with hi-intensity yellow foreground.
 // A newline is appended to format by default.
 func HiYellow(format string, a ...interface{}) { colorPrint(format, FgHiYellow, a...) }
 // HiBlue is a convenient helper function to print with hi-intensity blue foreground. A
 // newline is appended to format by default.
 func HiBlue(format string, a ...interface{}) { colorPrint(format, FgHiBlue, a...) }
 // HiMagenta is a convenient helper function to print with hi-intensity magenta foreground.
 // A newline is appended to format by default.
 func HiMagenta(format string, a ...interface{}) { colorPrint(format, FgHiMagenta, a...) }
 // HiCyan is a convenient helper function to print with hi-intensity cyan foreground. A
 // newline is appended to format by default.
 func HiCyan(format string, a ...interface{}) { colorPrint(format, FgHiCyan, a...) }
 // HiWhite is a convenient helper function to print with hi-intensity white foreground. A
 // newline is appended to format by default.
 func HiWhite(format string, a ...interface{}) { colorPrint(format, FgHiWhite, a...) }
 // HiBlackString is a convenient helper function to return a string with hi-intensity black
 // foreground.
 func HiBlackString(format string, a ...interface{}) string {
 	return colorString(format, FgHiBlack, a...)
 }
 // HiRedString is a convenient helper function to return a string with hi-intensity red
 // foreground.
 func HiRedString(format string, a ...interface{}) string { return colorString(format, FgHiRed, a...) }
 // HiGreenString is a convenient helper function to return a string with hi-intensity green
 // foreground.
 func HiGreenString(format string, a ...interface{}) string {
 	return colorString(format, FgHiGreen, a...)
 }
 // HiYellowString is a convenient helper function to return a string with hi-intensity yellow
 // foreground.
 func HiYellowString(format string, a ...interface{}) string {
 	return colorString(format, FgHiYellow, a...)
 }
 // HiBlueString is a convenient helper function to return a string with hi-intensity blue
 // foreground.
 func HiBlueString(format string, a ...interface{}) string { return colorString(format, FgHiBlue, a...) }
 // HiMagentaString is a convenient helper function to return a string with hi-intensity magenta
 // foreground.
 func HiMagentaString(format string, a ...interface{}) string {
 	return colorString(format, FgHiMagenta, a...)
 }
 // HiCyanString is a convenient helper function to return a string with hi-intensity cyan
 // foreground.
 func HiCyanString(format string, a ...interface{}) string { return colorString(format, FgHiCyan, a...) }
 // HiWhiteString is a convenient helper function to return a string with hi-intensity white
 // foreground.
 func HiWhiteString(format string, a ...interface{}) string {
 	return colorString(format, FgHiWhite, a...)
 }
--- a/vendor/github.com/fatih/color/doc.go
+++ b/vendor/github.com/fatih/color/doc.go
@ -0,0 +1,133 @@
 /*
 Package color is an ANSI color package to output colorized or SGR defined
 output to the standard output. The API can be used in several way, pick one
 that suits you.
 Use simple and default helper functions with predefined foreground colors:
    color.Cyan("Prints text in cyan.")
    // a newline will be appended automatically
    color.Blue("Prints %s in blue.", "text")
    // More default foreground colors..
    color.Red("We have red")
    color.Yellow("Yellow color too!")
    color.Magenta("And many others ..")
    // Hi-intensity colors
    color.HiGreen("Bright green color.")
    color.HiBlack("Bright black means gray..")
    color.HiWhite("Shiny white color!")
 However there are times where custom color mixes are required. Below are some
 examples to create custom color objects and use the print functions of each
 separate color object.
    // Create a new color object
    c := color.New(color.FgCyan).Add(color.Underline)
    c.Println("Prints cyan text with an underline.")
    // Or just add them to New()
    d := color.New(color.FgCyan, color.Bold)
    d.Printf("This prints bold cyan %s\n", "too!.")
    // Mix up foreground and background colors, create new mixes!
    red := color.New(color.FgRed)
    boldRed := red.Add(color.Bold)
    boldRed.Println("This will print text in bold red.")
    whiteBackground := red.Add(color.BgWhite)
    whiteBackground.Println("Red text with White background.")
    // Use your own io.Writer output
    color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
    blue := color.New(color.FgBlue)
    blue.Fprint(myWriter, "This will print text in blue.")
 You can create PrintXxx functions to simplify even more:
    // Create a custom print function for convenient
    red := color.New(color.FgRed).PrintfFunc()
    red("warning")
    red("error: %s", err)
    // Mix up multiple attributes
    notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
    notice("don't forget this...")
 You can also FprintXxx functions to pass your own io.Writer:
    blue := color.New(FgBlue).FprintfFunc()
    blue(myWriter, "important notice: %s", stars)
    // Mix up with multiple attributes
    success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
    success(myWriter, don't forget this...")
 Or create SprintXxx functions to mix strings with other non-colorized strings:
    yellow := New(FgYellow).SprintFunc()
    red := New(FgRed).SprintFunc()
    fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error"))
    info := New(FgWhite, BgGreen).SprintFunc()
    fmt.Printf("this %s rocks!\n", info("package"))
 Windows support is enabled by default. All Print functions work as intended.
 However only for color.SprintXXX functions, user should use fmt.FprintXXX and
 set the output to color.Output:
    fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
    info := New(FgWhite, BgGreen).SprintFunc()
    fmt.Fprintf(color.Output, "this %s rocks!\n", info("package"))
 Using with existing code is possible. Just use the Set() method to set the
 standard output to the given parameters. That way a rewrite of an existing
 code is not required.
    // Use handy standard colors.
    color.Set(color.FgYellow)
    fmt.Println("Existing text will be now in Yellow")
    fmt.Printf("This one %s\n", "too")
    color.Unset() // don't forget to unset
    // You can mix up parameters
    color.Set(color.FgMagenta, color.Bold)
    defer color.Unset() // use it in your function
    fmt.Println("All text will be now bold magenta.")
 There might be a case where you want to disable color output (for example to
 pipe the standard output of your app to somewhere else). `Color` has support to
 disable colors both globally and for single color definition. For example
 suppose you have a CLI app and a `--no-color` bool flag. You can easily disable
 the color output with:
    var flagNoColor = flag.Bool("no-color", false, "Disable color output")
    if *flagNoColor {
    	color.NoColor = true // disables colorized output
    }
 It also has support for single color definitions (local). You can
 disable/enable color output on the fly:
     c := color.New(color.FgCyan)
     c.Println("Prints cyan text")
     c.DisableColor()
     c.Println("This is printed without any color")
     c.EnableColor()
     c.Println("This prints again cyan...")
 */
 package color
--- a/vendor/github.com/jstemmer/go-junit-report/.gitignore
+++ b/vendor/github.com/jstemmer/go-junit-report/.gitignore
@ -1 +0,0 @@
 go-junit-report
--- a/vendor/github.com/jstemmer/go-junit-report/.travis.yml
+++ b/vendor/github.com/jstemmer/go-junit-report/.travis.yml
@ -1,13 +0,0 @@
 language: go
 go:
  - tip
  - "1.10.x"
  - "1.9.x"
  - "1.8.x"
  - "1.7.x"
  - "1.6.x"
  - "1.5.x"
  - "1.4.x"
  - "1.3.x"
  - "1.2.x"
--- a/vendor/github.com/jstemmer/go-junit-report/BUILD
+++ b/vendor/github.com/jstemmer/go-junit-report/BUILD
@ -1,38 +0,0 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library")
 go_library(
    name = "go_default_library",
    srcs = ["go-junit-report.go"],
    importmap = "k8s.io/kubernetes/vendor/github.com/jstemmer/go-junit-report",
    importpath = "github.com/jstemmer/go-junit-report",
    visibility = ["//visibility:private"],
    deps = [
        "//vendor/github.com/jstemmer/go-junit-report/formatter:go_default_library",
        "//vendor/github.com/jstemmer/go-junit-report/parser:go_default_library",
    ],
 )
 go_binary(
    name = "go-junit-report",
    embed = [":go_default_library"],
    tags = ["manual"],
    visibility = ["//visibility:public"],
 )
 filegroup(
    name = "package-srcs",
    srcs = glob(["**"]),
    tags = ["automanaged"],
    visibility = ["//visibility:private"],
 )
 filegroup(
    name = "all-srcs",
    srcs = [
        ":package-srcs",
        "//vendor/github.com/jstemmer/go-junit-report/formatter:all-srcs",
        "//vendor/github.com/jstemmer/go-junit-report/parser:all-srcs",
    ],
    tags = ["automanaged"],
    visibility = ["//visibility:public"],
 )
--- a/vendor/github.com/jstemmer/go-junit-report/LICENSE
+++ b/vendor/github.com/jstemmer/go-junit-report/LICENSE
@ -1,20 +0,0 @@
 Copyright (c) 2012 Joel Stemmer
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/jstemmer/go-junit-report/README.md
+++ b/vendor/github.com/jstemmer/go-junit-report/README.md
@ -1,46 +0,0 @@
 # go-junit-report
 Converts `go test` output to an xml report, suitable for applications that
 expect junit xml reports (e.g. [Jenkins](http://jenkins-ci.org)).
 [![Build Status][travis-badge]][travis-link]
 [![Report Card][report-badge]][report-link]
 ## Installation
 Go version 1.1 or higher is required. Install or update using the `go get`
 command:
 ```bash
 go get -u github.com/jstemmer/go-junit-report
 ```
 ## Contribution
 Create an Issue and discuss the fix or feature, then fork the package.
 Clone to github.com/jstemmer/go-junit-report.  This is necessary because go import uses this path.
 Fix or implement feature. Test and then commit change.
 Specify #Issue and describe change in the commit message.
 Create Pull Request. It can be merged by owner or administrator then.
 ## Run Tests
 go test
 ## Usage
 go-junit-report reads the `go test` verbose output from standard in and writes
 junit compatible XML to standard out.
 ```bash
 go test -v 2>&1 | go-junit-report > report.xml
 ```
 Note that it also can parse benchmark output with `-bench` flag:
 ```bash
 go test -v -bench . -count 5 2>&1 | go-junit-report > report.xml
 ```
 [travis-badge]: https://travis-ci.org/jstemmer/go-junit-report.svg
 [travis-link]: https://travis-ci.org/jstemmer/go-junit-report
 [report-badge]: https://goreportcard.com/badge/github.com/jstemmer/go-junit-report
 [report-link]: https://goreportcard.com/report/github.com/jstemmer/go-junit-report
--- a/vendor/github.com/jstemmer/go-junit-report/formatter/formatter.go
+++ b/vendor/github.com/jstemmer/go-junit-report/formatter/formatter.go
@ -1,182 +0,0 @@
 package formatter
 import (
 	"bufio"
 	"encoding/xml"
 	"fmt"
 	"io"
 	"runtime"
 	"strings"
 	"time"
 	"github.com/jstemmer/go-junit-report/parser"
 )
 // JUnitTestSuites is a collection of JUnit test suites.
 type JUnitTestSuites struct {
 	XMLName xml.Name `xml:"testsuites"`
 	Suites  []JUnitTestSuite
 }
 // JUnitTestSuite is a single JUnit test suite which may contain many
 // testcases.
 type JUnitTestSuite struct {
 	XMLName    xml.Name        `xml:"testsuite"`
 	Tests      int             `xml:"tests,attr"`
 	Failures   int             `xml:"failures,attr"`
 	Time       string          `xml:"time,attr"`
 	Name       string          `xml:"name,attr"`
 	Properties []JUnitProperty `xml:"properties>property,omitempty"`
 	TestCases  []JUnitTestCase
 }
 // JUnitTestCase is a single test case with its result.
 type JUnitTestCase struct {
 	XMLName     xml.Name          `xml:"testcase"`
 	Classname   string            `xml:"classname,attr"`
 	Name        string            `xml:"name,attr"`
 	Time        string            `xml:"time,attr"`
 	SkipMessage *JUnitSkipMessage `xml:"skipped,omitempty"`
 	Failure     *JUnitFailure     `xml:"failure,omitempty"`
 }
 // JUnitSkipMessage contains the reason why a testcase was skipped.
 type JUnitSkipMessage struct {
 	Message string `xml:"message,attr"`
 }
 // JUnitProperty represents a key/value pair used to define properties.
 type JUnitProperty struct {
 	Name  string `xml:"name,attr"`
 	Value string `xml:"value,attr"`
 }
 // JUnitFailure contains data related to a failed test.
 type JUnitFailure struct {
 	Message  string `xml:"message,attr"`
 	Type     string `xml:"type,attr"`
 	Contents string `xml:",chardata"`
 }
 // JUnitReportXML writes a JUnit xml representation of the given report to w
 // in the format described at http://windyroad.org/dl/Open%20Source/JUnit.xsd
 func JUnitReportXML(report *parser.Report, noXMLHeader bool, goVersion string, w io.Writer) error {
 	suites := JUnitTestSuites{}
 	// convert Report to JUnit test suites
 	for _, pkg := range report.Packages {
 		pkg.Benchmarks = mergeBenchmarks(pkg.Benchmarks)
 		ts := JUnitTestSuite{
 			Tests:      len(pkg.Tests) + len(pkg.Benchmarks),
 			Failures:   0,
 			Time:       formatTime(pkg.Duration),
 			Name:       pkg.Name,
 			Properties: []JUnitProperty{},
 			TestCases:  []JUnitTestCase{},
 		}
 		classname := pkg.Name
 		if idx := strings.LastIndex(classname, "/"); idx > -1 && idx < len(pkg.Name) {
 			classname = pkg.Name[idx+1:]
 		}
 		// properties
 		if goVersion == "" {
 			// if goVersion was not specified as a flag, fall back to version reported by runtime
 			goVersion = runtime.Version()
 		}
 		ts.Properties = append(ts.Properties, JUnitProperty{"go.version", goVersion})
 		if pkg.CoveragePct != "" {
 			ts.Properties = append(ts.Properties, JUnitProperty{"coverage.statements.pct", pkg.CoveragePct})
 		}
 		// individual test cases
 		for _, test := range pkg.Tests {
 			testCase := JUnitTestCase{
 				Classname: classname,
 				Name:      test.Name,
 				Time:      formatTime(test.Duration),
 				Failure:   nil,
 			}
 			if test.Result == parser.FAIL {
 				ts.Failures++
 				testCase.Failure = &JUnitFailure{
 					Message:  "Failed",
 					Type:     "",
 					Contents: strings.Join(test.Output, "\n"),
 				}
 			}
 			if test.Result == parser.SKIP {
 				testCase.SkipMessage = &JUnitSkipMessage{strings.Join(test.Output, "\n")}
 			}
 			ts.TestCases = append(ts.TestCases, testCase)
 		}
 		// individual benchmarks
 		for _, benchmark := range pkg.Benchmarks {
 			benchmarkCase := JUnitTestCase{
 				Classname: classname,
 				Name:      benchmark.Name,
 				Time:      formatBenchmarkTime(benchmark.Duration),
 			}
 			ts.TestCases = append(ts.TestCases, benchmarkCase)
 		}
 		suites.Suites = append(suites.Suites, ts)
 	}
 	// to xml
 	bytes, err := xml.MarshalIndent(suites, "", "\t")
 	if err != nil {
 		return err
 	}
 	writer := bufio.NewWriter(w)
 	if !noXMLHeader {
 		writer.WriteString(xml.Header)
 	}
 	writer.Write(bytes)
 	writer.WriteByte('\n')
 	writer.Flush()
 	return nil
 }
 func mergeBenchmarks(benchmarks []*parser.Benchmark) []*parser.Benchmark {
 	var merged []*parser.Benchmark
 	benchmap := make(map[string][]*parser.Benchmark)
 	for _, bm := range benchmarks {
 		if _, ok := benchmap[bm.Name]; !ok {
 			merged = append(merged, &parser.Benchmark{Name: bm.Name})
 		}
 		benchmap[bm.Name] = append(benchmap[bm.Name], bm)
 	}
 	for _, bm := range merged {
 		for _, b := range benchmap[bm.Name] {
 			bm.Allocs += b.Allocs
 			bm.Bytes += b.Bytes
 			bm.Duration += b.Duration
 		}
 		n := len(benchmap[bm.Name])
 		bm.Allocs /= n
 		bm.Bytes /= n
 		bm.Duration /= time.Duration(n)
 	}
 	return merged
 }
 func formatTime(d time.Duration) string {
 	return fmt.Sprintf("%.3f", d.Seconds())
 }
 func formatBenchmarkTime(d time.Duration) string {
 	return fmt.Sprintf("%.9f", d.Seconds())
 }
--- a/vendor/github.com/jstemmer/go-junit-report/go-junit-report.go
+++ b/vendor/github.com/jstemmer/go-junit-report/go-junit-report.go
@ -1,51 +0,0 @@
 package main
 import (
 	"flag"
 	"fmt"
 	"os"
 	"github.com/jstemmer/go-junit-report/formatter"
 	"github.com/jstemmer/go-junit-report/parser"
 )
 var (
 	noXMLHeader   bool
 	packageName   string
 	goVersionFlag string
 	setExitCode   bool
 )
 func init() {
 	flag.BoolVar(&noXMLHeader, "no-xml-header", false, "do not print xml header")
 	flag.StringVar(&packageName, "package-name", "", "specify a package name (compiled test have no package name in output)")
 	flag.StringVar(&goVersionFlag, "go-version", "", "specify the value to use for the go.version property in the generated XML")
 	flag.BoolVar(&setExitCode, "set-exit-code", false, "set exit code to 1 if tests failed")
 }
 func main() {
 	flag.Parse()
 	if flag.NArg() != 0 {
 		fmt.Println("go-junit-report does not accept positional arguments")
 		os.Exit(1)
 	}
 	// Read input
 	report, err := parser.Parse(os.Stdin, packageName)
 	if err != nil {
 		fmt.Printf("Error reading input: %s\n", err)
 		os.Exit(1)
 	}
 	// Write xml
 	err = formatter.JUnitReportXML(report, noXMLHeader, goVersionFlag, os.Stdout)
 	if err != nil {
 		fmt.Printf("Error writing XML: %s\n", err)
 		os.Exit(1)
 	}
 	if setExitCode && report.Failures() > 0 {
 		os.Exit(1)
 	}
 }
--- a/vendor/github.com/jstemmer/go-junit-report/parser/parser.go
+++ b/vendor/github.com/jstemmer/go-junit-report/parser/parser.go
@ -1,303 +0,0 @@
 package parser
 import (
 	"bufio"
 	"io"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 )
 // Result represents a test result.
 type Result int
 // Test result constants
 const (
 	PASS Result = iota
 	FAIL
 	SKIP
 )
 // Report is a collection of package tests.
 type Report struct {
 	Packages []Package
 }
 // Package contains the test results of a single package.
 type Package struct {
 	Name        string
 	Duration    time.Duration
 	Tests       []*Test
 	Benchmarks  []*Benchmark
 	CoveragePct string
 	// Time is deprecated, use Duration instead.
 	Time int // in milliseconds
 }
 // Test contains the results of a single test.
 type Test struct {
 	Name     string
 	Duration time.Duration
 	Result   Result
 	Output   []string
 	SubtestIndent string
 	// Time is deprecated, use Duration instead.
 	Time int // in milliseconds
 }
 // Benchmark contains the results of a single benchmark.
 type Benchmark struct {
 	Name     string
 	Duration time.Duration
 	// number of B/op
 	Bytes int
 	// number of allocs/op
 	Allocs int
 }
 var (
 	regexStatus   = regexp.MustCompile(`--- (PASS|FAIL|SKIP): (.+) \((\d+\.\d+)(?: seconds|s)\)`)
 	regexIndent   = regexp.MustCompile(`^([ \t]+)---`)
 	regexCoverage = regexp.MustCompile(`^coverage:\s+(\d+\.\d+)%\s+of\s+statements(?:\sin\s.+)?$`)
 	regexResult   = regexp.MustCompile(`^(ok|FAIL)\s+([^ ]+)\s+(?:(\d+\.\d+)s|\(cached\)|(\[\w+ failed]))(?:\s+coverage:\s+(\d+\.\d+)%\sof\sstatements(?:\sin\s.+)?)?$`)
 	// regexBenchmark captures 3-5 groups: benchmark name, number of times ran, ns/op (with or without decimal), B/op (optional), and allocs/op (optional).
 	regexBenchmark = regexp.MustCompile(`^(Benchmark[^ -]+)(?:-\d+\s+|\s+)(\d+)\s+(\d+|\d+\.\d+)\sns/op(?:\s+(\d+)\sB/op)?(?:\s+(\d+)\sallocs/op)?`)
 	regexOutput    = regexp.MustCompile(`(    )*\t(.*)`)
 	regexSummary   = regexp.MustCompile(`^(PASS|FAIL|SKIP)$`)
 )
 // Parse parses go test output from reader r and returns a report with the
 // results. An optional pkgName can be given, which is used in case a package
 // result line is missing.
 func Parse(r io.Reader, pkgName string) (*Report, error) {
 	reader := bufio.NewReader(r)
 	report := &Report{make([]Package, 0)}
 	// keep track of tests we find
 	var tests []*Test
 	// keep track of benchmarks we find
 	var benchmarks []*Benchmark
 	// sum of tests' time, use this if current test has no result line (when it is compiled test)
 	var testsTime time.Duration
 	// current test
 	var cur string
 	// keep track if we've already seen a summary for the current test
 	var seenSummary bool
 	// coverage percentage report for current package
 	var coveragePct string
 	// stores mapping between package name and output of build failures
 	var packageCaptures = map[string][]string{}
 	// the name of the package which it's build failure output is being captured
 	var capturedPackage string
 	// capture any non-test output
 	var buffers = map[string][]string{}
 	// parse lines
 	for {
 		l, _, err := reader.ReadLine()
 		if err != nil && err == io.EOF {
 			break
 		} else if err != nil {
 			return nil, err
 		}
 		line := string(l)
 		if strings.HasPrefix(line, "=== RUN ") {
 			// new test
 			cur = strings.TrimSpace(line[8:])
 			tests = append(tests, &Test{
 				Name:   cur,
 				Result: FAIL,
 				Output: make([]string, 0),
 			})
 			// clear the current build package, so output lines won't be added to that build
 			capturedPackage = ""
 			seenSummary = false
 		} else if matches := regexBenchmark.FindStringSubmatch(line); len(matches) == 6 {
 			bytes, _ := strconv.Atoi(matches[4])
 			allocs, _ := strconv.Atoi(matches[5])
 			benchmarks = append(benchmarks, &Benchmark{
 				Name:     matches[1],
 				Duration: parseNanoseconds(matches[3]),
 				Bytes:    bytes,
 				Allocs:   allocs,
 			})
 		} else if strings.HasPrefix(line, "=== PAUSE ") {
 			continue
 		} else if strings.HasPrefix(line, "=== CONT ") {
 			cur = strings.TrimSpace(line[8:])
 			continue
 		} else if matches := regexResult.FindStringSubmatch(line); len(matches) == 6 {
 			if matches[5] != "" {
 				coveragePct = matches[5]
 			}
 			if strings.HasSuffix(matches[4], "failed]") {
 				// the build of the package failed, inject a dummy test into the package
 				// which indicate about the failure and contain the failure description.
 				tests = append(tests, &Test{
 					Name:   matches[4],
 					Result: FAIL,
 					Output: packageCaptures[matches[2]],
 				})
 			} else if matches[1] == "FAIL" && len(tests) == 0 && len(buffers[cur]) > 0 {
 				// This package didn't have any tests, but it failed with some
 				// output. Create a dummy test with the output.
 				tests = append(tests, &Test{
 					Name:   "Failure",
 					Result: FAIL,
 					Output: buffers[cur],
 				})
 				buffers[cur] = buffers[cur][0:0]
 			}
 			// all tests in this package are finished
 			report.Packages = append(report.Packages, Package{
 				Name:        matches[2],
 				Duration:    parseSeconds(matches[3]),
 				Tests:       tests,
 				Benchmarks:  benchmarks,
 				CoveragePct: coveragePct,
 				Time: int(parseSeconds(matches[3]) / time.Millisecond), // deprecated
 			})
 			buffers[cur] = buffers[cur][0:0]
 			tests = make([]*Test, 0)
 			benchmarks = make([]*Benchmark, 0)
 			coveragePct = ""
 			cur = ""
 			testsTime = 0
 		} else if matches := regexStatus.FindStringSubmatch(line); len(matches) == 4 {
 			cur = matches[2]
 			test := findTest(tests, cur)
 			if test == nil {
 				continue
 			}
 			// test status
 			if matches[1] == "PASS" {
 				test.Result = PASS
 			} else if matches[1] == "SKIP" {
 				test.Result = SKIP
 			} else {
 				test.Result = FAIL
 			}
 			if matches := regexIndent.FindStringSubmatch(line); len(matches) == 2 {
 				test.SubtestIndent = matches[1]
 			}
 			test.Output = buffers[cur]
 			test.Name = matches[2]
 			test.Duration = parseSeconds(matches[3])
 			testsTime += test.Duration
 			test.Time = int(test.Duration / time.Millisecond) // deprecated
 		} else if matches := regexCoverage.FindStringSubmatch(line); len(matches) == 2 {
 			coveragePct = matches[1]
 		} else if matches := regexOutput.FindStringSubmatch(line); capturedPackage == "" && len(matches) == 3 {
 			// Sub-tests start with one or more series of 4-space indents, followed by a hard tab,
 			// followed by the test output
 			// Top-level tests start with a hard tab.
 			test := findTest(tests, cur)
 			if test == nil {
 				continue
 			}
 			test.Output = append(test.Output, matches[2])
 		} else if strings.HasPrefix(line, "# ") {
 			// indicates a capture of build output of a package. set the current build package.
 			capturedPackage = line[2:]
 		} else if capturedPackage != "" {
 			// current line is build failure capture for the current built package
 			packageCaptures[capturedPackage] = append(packageCaptures[capturedPackage], line)
 		} else if regexSummary.MatchString(line) {
 			// don't store any output after the summary
 			seenSummary = true
 		} else if !seenSummary {
 			// buffer anything else that we didn't recognize
 			buffers[cur] = append(buffers[cur], line)
 			// if we have a current test, also append to its output
 			test := findTest(tests, cur)
 			if test != nil {
 				if strings.HasPrefix(line, test.SubtestIndent+"    ") {
 					test.Output = append(test.Output, strings.TrimPrefix(line, test.SubtestIndent+"    "))
 				}
 			}
 		}
 	}
 	if len(tests) > 0 {
 		// no result line found
 		report.Packages = append(report.Packages, Package{
 			Name:        pkgName,
 			Duration:    testsTime,
 			Time:        int(testsTime / time.Millisecond),
 			Tests:       tests,
 			Benchmarks:  benchmarks,
 			CoveragePct: coveragePct,
 		})
 	}
 	return report, nil
 }
 func parseSeconds(t string) time.Duration {
 	if t == "" {
 		return time.Duration(0)
 	}
 	// ignore error
 	d, _ := time.ParseDuration(t + "s")
 	return d
 }
 func parseNanoseconds(t string) time.Duration {
 	// note: if input < 1 ns precision, result will be 0s.
 	if t == "" {
 		return time.Duration(0)
 	}
 	// ignore error
 	d, _ := time.ParseDuration(t + "ns")
 	return d
 }
 func findTest(tests []*Test, name string) *Test {
 	for i := len(tests) - 1; i >= 0; i-- {
 		if tests[i].Name == name {
 			return tests[i]
 		}
 	}
 	return nil
 }
 // Failures counts the number of failed tests in this report
 func (r *Report) Failures() int {
 	count := 0
 	for _, p := range r.Packages {
 		for _, t := range p.Tests {
 			if t.Result == FAIL {
 				count++
 			}
 		}
 	}
 	return count
 }
--- a/vendor/github.com/mattn/go-colorable/.travis.yml
+++ b/vendor/github.com/mattn/go-colorable/.travis.yml
@ -0,0 +1,9 @@
 language: go
 go:
  - tip
 before_install:
  - go get github.com/mattn/goveralls
  - go get golang.org/x/tools/cmd/cover
 script:
  - $HOME/gopath/bin/goveralls -repotoken xnXqRGwgW3SXIguzxf90ZSK1GPYZPaGrw
--- a/vendor/github.com/mattn/go-colorable/BUILD
+++ b/vendor/github.com/mattn/go-colorable/BUILD
@ -0,0 +1,63 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
    name = "go_default_library",
    srcs = [
        "colorable_others.go",
        "colorable_windows.go",
        "noncolorable.go",
    ],
    importmap = "k8s.io/kubernetes/vendor/github.com/mattn/go-colorable",
    importpath = "github.com/mattn/go-colorable",
    visibility = ["//visibility:public"],
    deps = select({
        "@io_bazel_rules_go//go/platform:android": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:darwin": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:dragonfly": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:freebsd": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:linux": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:nacl": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:netbsd": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:openbsd": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:plan9": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:solaris": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:windows": [
            "//vendor/github.com/mattn/go-isatty:go_default_library",
        ],
        "//conditions:default": [],
    }),
 )
 filegroup(
    name = "package-srcs",
    srcs = glob(["**"]),
    tags = ["automanaged"],
    visibility = ["//visibility:private"],
 )
 filegroup(
    name = "all-srcs",
    srcs = [":package-srcs"],
    tags = ["automanaged"],
    visibility = ["//visibility:public"],
 )
--- a/vendor/github.com/mattn/go-colorable/LICENSE
+++ b/vendor/github.com/mattn/go-colorable/LICENSE
@ -0,0 +1,21 @@
 The MIT License (MIT)
 Copyright (c) 2016 Yasuhiro Matsumoto
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/vendor/github.com/mattn/go-colorable/README.md
+++ b/vendor/github.com/mattn/go-colorable/README.md
@ -0,0 +1,48 @@
 # go-colorable
 [![Godoc Reference](https://godoc.org/github.com/mattn/go-colorable?status.svg)](http://godoc.org/github.com/mattn/go-colorable)
 [![Build Status](https://travis-ci.org/mattn/go-colorable.svg?branch=master)](https://travis-ci.org/mattn/go-colorable)
 [![Coverage Status](https://coveralls.io/repos/github/mattn/go-colorable/badge.svg?branch=master)](https://coveralls.io/github/mattn/go-colorable?branch=master)
 [![Go Report Card](https://goreportcard.com/badge/mattn/go-colorable)](https://goreportcard.com/report/mattn/go-colorable)
 Colorable writer for windows.
 For example, most of logger packages doesn't show colors on windows. (I know we can do it with ansicon. But I don't want.)
 This package is possible to handle escape sequence for ansi color on windows.
 ## Too Bad!
 ![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/bad.png)
 ## So Good!
 ![](https://raw.githubusercontent.com/mattn/go-colorable/gh-pages/good.png)
 ## Usage
 ```go
 logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true})
 logrus.SetOutput(colorable.NewColorableStdout())
 logrus.Info("succeeded")
 logrus.Warn("not correct")
 logrus.Error("something error")
 logrus.Fatal("panic")
 ```
 You can compile above code on non-windows OSs.
 ## Installation
 ```
 $ go get github.com/mattn/go-colorable
 ```
 # License
 MIT
 # Author
 Yasuhiro Matsumoto (a.k.a mattn)
--- a/vendor/github.com/mattn/go-colorable/colorable_appengine.go
+++ b/vendor/github.com/mattn/go-colorable/colorable_appengine.go
@ -0,0 +1,29 @@
 // +build appengine
 package colorable
 import (
 	"io"
 	"os"
 	_ "github.com/mattn/go-isatty"
 )
 // NewColorable return new instance of Writer which handle escape sequence.
 func NewColorable(file *os.File) io.Writer {
 	if file == nil {
 		panic("nil passed instead of *os.File to NewColorable()")
 	}
 	return file
 }
 // NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
 func NewColorableStdout() io.Writer {
 	return os.Stdout
 }
 // NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
 func NewColorableStderr() io.Writer {
 	return os.Stderr
 }
--- a/vendor/github.com/mattn/go-colorable/colorable_others.go
+++ b/vendor/github.com/mattn/go-colorable/colorable_others.go
@ -0,0 +1,30 @@
 // +build !windows
 // +build !appengine
 package colorable
 import (
 	"io"
 	"os"
 	_ "github.com/mattn/go-isatty"
 )
 // NewColorable return new instance of Writer which handle escape sequence.
 func NewColorable(file *os.File) io.Writer {
 	if file == nil {
 		panic("nil passed instead of *os.File to NewColorable()")
 	}
 	return file
 }
 // NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
 func NewColorableStdout() io.Writer {
 	return os.Stdout
 }
 // NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
 func NewColorableStderr() io.Writer {
 	return os.Stderr
 }
--- a/vendor/github.com/mattn/go-colorable/colorable_windows.go
+++ b/vendor/github.com/mattn/go-colorable/colorable_windows.go
@ -0,0 +1,884 @@
 // +build windows
 // +build !appengine
 package colorable
 import (
 	"bytes"
 	"io"
 	"math"
 	"os"
 	"strconv"
 	"strings"
 	"syscall"
 	"unsafe"
 	"github.com/mattn/go-isatty"
 )
 const (
 	foregroundBlue      = 0x1
 	foregroundGreen     = 0x2
 	foregroundRed       = 0x4
 	foregroundIntensity = 0x8
 	foregroundMask      = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
 	backgroundBlue      = 0x10
 	backgroundGreen     = 0x20
 	backgroundRed       = 0x40
 	backgroundIntensity = 0x80
 	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
 )
 type wchar uint16
 type short int16
 type dword uint32
 type word uint16
 type coord struct {
 	x short
 	y short
 }
 type smallRect struct {
 	left   short
 	top    short
 	right  short
 	bottom short
 }
 type consoleScreenBufferInfo struct {
 	size              coord
 	cursorPosition    coord
 	attributes        word
 	window            smallRect
 	maximumWindowSize coord
 }
 type consoleCursorInfo struct {
 	size    dword
 	visible int32
 }
 var (
 	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
 	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
 	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
 	procSetConsoleCursorPosition   = kernel32.NewProc("SetConsoleCursorPosition")
 	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
 	procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute")
 	procGetConsoleCursorInfo       = kernel32.NewProc("GetConsoleCursorInfo")
 	procSetConsoleCursorInfo       = kernel32.NewProc("SetConsoleCursorInfo")
 	procSetConsoleTitle            = kernel32.NewProc("SetConsoleTitleW")
 )
 // Writer provide colorable Writer to the console
 type Writer struct {
 	out     io.Writer
 	handle  syscall.Handle
 	oldattr word
 	oldpos  coord
 }
 // NewColorable return new instance of Writer which handle escape sequence from File.
 func NewColorable(file *os.File) io.Writer {
 	if file == nil {
 		panic("nil passed instead of *os.File to NewColorable()")
 	}
 	if isatty.IsTerminal(file.Fd()) {
 		var csbi consoleScreenBufferInfo
 		handle := syscall.Handle(file.Fd())
 		procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
 		return &Writer{out: file, handle: handle, oldattr: csbi.attributes, oldpos: coord{0, 0}}
 	}
 	return file
 }
 // NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
 func NewColorableStdout() io.Writer {
 	return NewColorable(os.Stdout)
 }
 // NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
 func NewColorableStderr() io.Writer {
 	return NewColorable(os.Stderr)
 }
 var color256 = map[int]int{
 	0:   0x000000,
 	1:   0x800000,
 	2:   0x008000,
 	3:   0x808000,
 	4:   0x000080,
 	5:   0x800080,
 	6:   0x008080,
 	7:   0xc0c0c0,
 	8:   0x808080,
 	9:   0xff0000,
 	10:  0x00ff00,
 	11:  0xffff00,
 	12:  0x0000ff,
 	13:  0xff00ff,
 	14:  0x00ffff,
 	15:  0xffffff,
 	16:  0x000000,
 	17:  0x00005f,
 	18:  0x000087,
 	19:  0x0000af,
 	20:  0x0000d7,
 	21:  0x0000ff,
 	22:  0x005f00,
 	23:  0x005f5f,
 	24:  0x005f87,
 	25:  0x005faf,
 	26:  0x005fd7,
 	27:  0x005fff,
 	28:  0x008700,
 	29:  0x00875f,
 	30:  0x008787,
 	31:  0x0087af,
 	32:  0x0087d7,
 	33:  0x0087ff,
 	34:  0x00af00,
 	35:  0x00af5f,
 	36:  0x00af87,
 	37:  0x00afaf,
 	38:  0x00afd7,
 	39:  0x00afff,
 	40:  0x00d700,
 	41:  0x00d75f,
 	42:  0x00d787,
 	43:  0x00d7af,
 	44:  0x00d7d7,
 	45:  0x00d7ff,
 	46:  0x00ff00,
 	47:  0x00ff5f,
 	48:  0x00ff87,
 	49:  0x00ffaf,
 	50:  0x00ffd7,
 	51:  0x00ffff,
 	52:  0x5f0000,
 	53:  0x5f005f,
 	54:  0x5f0087,
 	55:  0x5f00af,
 	56:  0x5f00d7,
 	57:  0x5f00ff,
 	58:  0x5f5f00,
 	59:  0x5f5f5f,
 	60:  0x5f5f87,
 	61:  0x5f5faf,
 	62:  0x5f5fd7,
 	63:  0x5f5fff,
 	64:  0x5f8700,
 	65:  0x5f875f,
 	66:  0x5f8787,
 	67:  0x5f87af,
 	68:  0x5f87d7,
 	69:  0x5f87ff,
 	70:  0x5faf00,
 	71:  0x5faf5f,
 	72:  0x5faf87,
 	73:  0x5fafaf,
 	74:  0x5fafd7,
 	75:  0x5fafff,
 	76:  0x5fd700,
 	77:  0x5fd75f,
 	78:  0x5fd787,
 	79:  0x5fd7af,
 	80:  0x5fd7d7,
 	81:  0x5fd7ff,
 	82:  0x5fff00,
 	83:  0x5fff5f,
 	84:  0x5fff87,
 	85:  0x5fffaf,
 	86:  0x5fffd7,
 	87:  0x5fffff,
 	88:  0x870000,
 	89:  0x87005f,
 	90:  0x870087,
 	91:  0x8700af,
 	92:  0x8700d7,
 	93:  0x8700ff,
 	94:  0x875f00,
 	95:  0x875f5f,
 	96:  0x875f87,
 	97:  0x875faf,
 	98:  0x875fd7,
 	99:  0x875fff,
 	100: 0x878700,
 	101: 0x87875f,
 	102: 0x878787,
 	103: 0x8787af,
 	104: 0x8787d7,
 	105: 0x8787ff,
 	106: 0x87af00,
 	107: 0x87af5f,
 	108: 0x87af87,
 	109: 0x87afaf,
 	110: 0x87afd7,
 	111: 0x87afff,
 	112: 0x87d700,
 	113: 0x87d75f,
 	114: 0x87d787,
 	115: 0x87d7af,
 	116: 0x87d7d7,
 	117: 0x87d7ff,
 	118: 0x87ff00,
 	119: 0x87ff5f,
 	120: 0x87ff87,
 	121: 0x87ffaf,
 	122: 0x87ffd7,
 	123: 0x87ffff,
 	124: 0xaf0000,
 	125: 0xaf005f,
 	126: 0xaf0087,
 	127: 0xaf00af,
 	128: 0xaf00d7,
 	129: 0xaf00ff,
 	130: 0xaf5f00,
 	131: 0xaf5f5f,
 	132: 0xaf5f87,
 	133: 0xaf5faf,
 	134: 0xaf5fd7,
 	135: 0xaf5fff,
 	136: 0xaf8700,
 	137: 0xaf875f,
 	138: 0xaf8787,
 	139: 0xaf87af,
 	140: 0xaf87d7,
 	141: 0xaf87ff,
 	142: 0xafaf00,
 	143: 0xafaf5f,
 	144: 0xafaf87,
 	145: 0xafafaf,
 	146: 0xafafd7,
 	147: 0xafafff,
 	148: 0xafd700,
 	149: 0xafd75f,
 	150: 0xafd787,
 	151: 0xafd7af,
 	152: 0xafd7d7,
 	153: 0xafd7ff,
 	154: 0xafff00,
 	155: 0xafff5f,
 	156: 0xafff87,
 	157: 0xafffaf,
 	158: 0xafffd7,
 	159: 0xafffff,
 	160: 0xd70000,
 	161: 0xd7005f,
 	162: 0xd70087,
 	163: 0xd700af,
 	164: 0xd700d7,
 	165: 0xd700ff,
 	166: 0xd75f00,
 	167: 0xd75f5f,
 	168: 0xd75f87,
 	169: 0xd75faf,
 	170: 0xd75fd7,
 	171: 0xd75fff,
 	172: 0xd78700,
 	173: 0xd7875f,
 	174: 0xd78787,
 	175: 0xd787af,
 	176: 0xd787d7,
 	177: 0xd787ff,
 	178: 0xd7af00,
 	179: 0xd7af5f,
 	180: 0xd7af87,
 	181: 0xd7afaf,
 	182: 0xd7afd7,
 	183: 0xd7afff,
 	184: 0xd7d700,
 	185: 0xd7d75f,
 	186: 0xd7d787,
 	187: 0xd7d7af,
 	188: 0xd7d7d7,
 	189: 0xd7d7ff,
 	190: 0xd7ff00,
 	191: 0xd7ff5f,
 	192: 0xd7ff87,
 	193: 0xd7ffaf,
 	194: 0xd7ffd7,
 	195: 0xd7ffff,
 	196: 0xff0000,
 	197: 0xff005f,
 	198: 0xff0087,
 	199: 0xff00af,
 	200: 0xff00d7,
 	201: 0xff00ff,
 	202: 0xff5f00,
 	203: 0xff5f5f,
 	204: 0xff5f87,
 	205: 0xff5faf,
 	206: 0xff5fd7,
 	207: 0xff5fff,
 	208: 0xff8700,
 	209: 0xff875f,
 	210: 0xff8787,
 	211: 0xff87af,
 	212: 0xff87d7,
 	213: 0xff87ff,
 	214: 0xffaf00,
 	215: 0xffaf5f,
 	216: 0xffaf87,
 	217: 0xffafaf,
 	218: 0xffafd7,
 	219: 0xffafff,
 	220: 0xffd700,
 	221: 0xffd75f,
 	222: 0xffd787,
 	223: 0xffd7af,
 	224: 0xffd7d7,
 	225: 0xffd7ff,
 	226: 0xffff00,
 	227: 0xffff5f,
 	228: 0xffff87,
 	229: 0xffffaf,
 	230: 0xffffd7,
 	231: 0xffffff,
 	232: 0x080808,
 	233: 0x121212,
 	234: 0x1c1c1c,
 	235: 0x262626,
 	236: 0x303030,
 	237: 0x3a3a3a,
 	238: 0x444444,
 	239: 0x4e4e4e,
 	240: 0x585858,
 	241: 0x626262,
 	242: 0x6c6c6c,
 	243: 0x767676,
 	244: 0x808080,
 	245: 0x8a8a8a,
 	246: 0x949494,
 	247: 0x9e9e9e,
 	248: 0xa8a8a8,
 	249: 0xb2b2b2,
 	250: 0xbcbcbc,
 	251: 0xc6c6c6,
 	252: 0xd0d0d0,
 	253: 0xdadada,
 	254: 0xe4e4e4,
 	255: 0xeeeeee,
 }
 // `\033]0;TITLESTR\007`
 func doTitleSequence(er *bytes.Reader) error {
 	var c byte
 	var err error
 	c, err = er.ReadByte()
 	if err != nil {
 		return err
 	}
 	if c != '0' && c != '2' {
 		return nil
 	}
 	c, err = er.ReadByte()
 	if err != nil {
 		return err
 	}
 	if c != ';' {
 		return nil
 	}
 	title := make([]byte, 0, 80)
 	for {
 		c, err = er.ReadByte()
 		if err != nil {
 			return err
 		}
 		if c == 0x07 || c == '\n' {
 			break
 		}
 		title = append(title, c)
 	}
 	if len(title) > 0 {
 		title8, err := syscall.UTF16PtrFromString(string(title))
 		if err == nil {
 			procSetConsoleTitle.Call(uintptr(unsafe.Pointer(title8)))
 		}
 	}
 	return nil
 }
 // Write write data on console
 func (w *Writer) Write(data []byte) (n int, err error) {
 	var csbi consoleScreenBufferInfo
 	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 	er := bytes.NewReader(data)
 	var bw [1]byte
 loop:
 	for {
 		c1, err := er.ReadByte()
 		if err != nil {
 			break loop
 		}
 		if c1 != 0x1b {
 			bw[0] = c1
 			w.out.Write(bw[:])
 			continue
 		}
 		c2, err := er.ReadByte()
 		if err != nil {
 			break loop
 		}
 		if c2 == ']' {
 			if err := doTitleSequence(er); err != nil {
 				break loop
 			}
 			continue
 		}
 		if c2 != 0x5b {
 			continue
 		}
 		var buf bytes.Buffer
 		var m byte
 		for {
 			c, err := er.ReadByte()
 			if err != nil {
 				break loop
 			}
 			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
 				m = c
 				break
 			}
 			buf.Write([]byte(string(c)))
 		}
 		switch m {
 		case 'A':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.y -= short(n)
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'B':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.y += short(n)
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'C':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x += short(n)
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'D':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x -= short(n)
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'E':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x = 0
 			csbi.cursorPosition.y += short(n)
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'F':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x = 0
 			csbi.cursorPosition.y -= short(n)
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'G':
 			n, err = strconv.Atoi(buf.String())
 			if err != nil {
 				continue
 			}
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			csbi.cursorPosition.x = short(n - 1)
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'H', 'f':
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			if buf.Len() > 0 {
 				token := strings.Split(buf.String(), ";")
 				switch len(token) {
 				case 1:
 					n1, err := strconv.Atoi(token[0])
 					if err != nil {
 						continue
 					}
 					csbi.cursorPosition.y = short(n1 - 1)
 				case 2:
 					n1, err := strconv.Atoi(token[0])
 					if err != nil {
 						continue
 					}
 					n2, err := strconv.Atoi(token[1])
 					if err != nil {
 						continue
 					}
 					csbi.cursorPosition.x = short(n2 - 1)
 					csbi.cursorPosition.y = short(n1 - 1)
 				}
 			} else {
 				csbi.cursorPosition.y = 0
 			}
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
 		case 'J':
 			n := 0
 			if buf.Len() > 0 {
 				n, err = strconv.Atoi(buf.String())
 				if err != nil {
 					continue
 				}
 			}
 			var count, written dword
 			var cursor coord
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			switch n {
 			case 0:
 				cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y}
 				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
 			case 1:
 				cursor = coord{x: csbi.window.left, y: csbi.window.top}
 				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.window.top-csbi.cursorPosition.y)*csbi.size.x)
 			case 2:
 				cursor = coord{x: csbi.window.left, y: csbi.window.top}
 				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
 			}
 			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
 			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
 		case 'K':
 			n := 0
 			if buf.Len() > 0 {
 				n, err = strconv.Atoi(buf.String())
 				if err != nil {
 					continue
 				}
 			}
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			var cursor coord
 			var count, written dword
 			switch n {
 			case 0:
 				cursor = coord{x: csbi.cursorPosition.x + 1, y: csbi.cursorPosition.y}
 				count = dword(csbi.size.x - csbi.cursorPosition.x - 1)
 			case 1:
 				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
 				count = dword(csbi.size.x - csbi.cursorPosition.x)
 			case 2:
 				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
 				count = dword(csbi.size.x)
 			}
 			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
 			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
 		case 'm':
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			attr := csbi.attributes
 			cs := buf.String()
 			if cs == "" {
 				procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr))
 				continue
 			}
 			token := strings.Split(cs, ";")
 			for i := 0; i < len(token); i++ {
 				ns := token[i]
 				if n, err = strconv.Atoi(ns); err == nil {
 					switch {
 					case n == 0 || n == 100:
 						attr = w.oldattr
 					case 1 <= n && n <= 5:
 						attr |= foregroundIntensity
 					case n == 7:
 						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
 					case n == 22 || n == 25:
 						attr |= foregroundIntensity
 					case n == 27:
 						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
 					case 30 <= n && n <= 37:
 						attr &= backgroundMask
 						if (n-30)&1 != 0 {
 							attr |= foregroundRed
 						}
 						if (n-30)&2 != 0 {
 							attr |= foregroundGreen
 						}
 						if (n-30)&4 != 0 {
 							attr |= foregroundBlue
 						}
 					case n == 38: // set foreground color.
 						if i < len(token)-2 && (token[i+1] == "5" || token[i+1] == "05") {
 							if n256, err := strconv.Atoi(token[i+2]); err == nil {
 								if n256foreAttr == nil {
 									n256setup()
 								}
 								attr &= backgroundMask
 								attr |= n256foreAttr[n256]
 								i += 2
 							}
 						} else {
 							attr = attr & (w.oldattr & backgroundMask)
 						}
 					case n == 39: // reset foreground color.
 						attr &= backgroundMask
 						attr |= w.oldattr & foregroundMask
 					case 40 <= n && n <= 47:
 						attr &= foregroundMask
 						if (n-40)&1 != 0 {
 							attr |= backgroundRed
 						}
 						if (n-40)&2 != 0 {
 							attr |= backgroundGreen
 						}
 						if (n-40)&4 != 0 {
 							attr |= backgroundBlue
 						}
 					case n == 48: // set background color.
 						if i < len(token)-2 && token[i+1] == "5" {
 							if n256, err := strconv.Atoi(token[i+2]); err == nil {
 								if n256backAttr == nil {
 									n256setup()
 								}
 								attr &= foregroundMask
 								attr |= n256backAttr[n256]
 								i += 2
 							}
 						} else {
 							attr = attr & (w.oldattr & foregroundMask)
 						}
 					case n == 49: // reset foreground color.
 						attr &= foregroundMask
 						attr |= w.oldattr & backgroundMask
 					case 90 <= n && n <= 97:
 						attr = (attr & backgroundMask)
 						attr |= foregroundIntensity
 						if (n-90)&1 != 0 {
 							attr |= foregroundRed
 						}
 						if (n-90)&2 != 0 {
 							attr |= foregroundGreen
 						}
 						if (n-90)&4 != 0 {
 							attr |= foregroundBlue
 						}
 					case 100 <= n && n <= 107:
 						attr = (attr & foregroundMask)
 						attr |= backgroundIntensity
 						if (n-100)&1 != 0 {
 							attr |= backgroundRed
 						}
 						if (n-100)&2 != 0 {
 							attr |= backgroundGreen
 						}
 						if (n-100)&4 != 0 {
 							attr |= backgroundBlue
 						}
 					}
 					procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
 				}
 			}
 		case 'h':
 			var ci consoleCursorInfo
 			cs := buf.String()
 			if cs == "5>" {
 				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
 				ci.visible = 0
 				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
 			} else if cs == "?25" {
 				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
 				ci.visible = 1
 				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
 			}
 		case 'l':
 			var ci consoleCursorInfo
 			cs := buf.String()
 			if cs == "5>" {
 				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
 				ci.visible = 1
 				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
 			} else if cs == "?25" {
 				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
 				ci.visible = 0
 				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
 			}
 		case 's':
 			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
 			w.oldpos = csbi.cursorPosition
 		case 'u':
 			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&w.oldpos)))
 		}
 	}
 	return len(data), nil
 }
 type consoleColor struct {
 	rgb       int
 	red       bool
 	green     bool
 	blue      bool
 	intensity bool
 }
 func (c consoleColor) foregroundAttr() (attr word) {
 	if c.red {
 		attr |= foregroundRed
 	}
 	if c.green {
 		attr |= foregroundGreen
 	}
 	if c.blue {
 		attr |= foregroundBlue
 	}
 	if c.intensity {
 		attr |= foregroundIntensity
 	}
 	return
 }
 func (c consoleColor) backgroundAttr() (attr word) {
 	if c.red {
 		attr |= backgroundRed
 	}
 	if c.green {
 		attr |= backgroundGreen
 	}
 	if c.blue {
 		attr |= backgroundBlue
 	}
 	if c.intensity {
 		attr |= backgroundIntensity
 	}
 	return
 }
 var color16 = []consoleColor{
 	{0x000000, false, false, false, false},
 	{0x000080, false, false, true, false},
 	{0x008000, false, true, false, false},
 	{0x008080, false, true, true, false},
 	{0x800000, true, false, false, false},
 	{0x800080, true, false, true, false},
 	{0x808000, true, true, false, false},
 	{0xc0c0c0, true, true, true, false},
 	{0x808080, false, false, false, true},
 	{0x0000ff, false, false, true, true},
 	{0x00ff00, false, true, false, true},
 	{0x00ffff, false, true, true, true},
 	{0xff0000, true, false, false, true},
 	{0xff00ff, true, false, true, true},
 	{0xffff00, true, true, false, true},
 	{0xffffff, true, true, true, true},
 }
 type hsv struct {
 	h, s, v float32
 }
 func (a hsv) dist(b hsv) float32 {
 	dh := a.h - b.h
 	switch {
 	case dh > 0.5:
 		dh = 1 - dh
 	case dh < -0.5:
 		dh = -1 - dh
 	}
 	ds := a.s - b.s
 	dv := a.v - b.v
 	return float32(math.Sqrt(float64(dh*dh + ds*ds + dv*dv)))
 }
 func toHSV(rgb int) hsv {
 	r, g, b := float32((rgb&0xFF0000)>>16)/256.0,
 		float32((rgb&0x00FF00)>>8)/256.0,
 		float32(rgb&0x0000FF)/256.0
 	min, max := minmax3f(r, g, b)
 	h := max - min
 	if h > 0 {
 		if max == r {
 			h = (g - b) / h
 			if h < 0 {
 				h += 6
 			}
 		} else if max == g {
 			h = 2 + (b-r)/h
 		} else {
 			h = 4 + (r-g)/h
 		}
 	}
 	h /= 6.0
 	s := max - min
 	if max != 0 {
 		s /= max
 	}
 	v := max
 	return hsv{h: h, s: s, v: v}
 }
 type hsvTable []hsv
 func toHSVTable(rgbTable []consoleColor) hsvTable {
 	t := make(hsvTable, len(rgbTable))
 	for i, c := range rgbTable {
 		t[i] = toHSV(c.rgb)
 	}
 	return t
 }
 func (t hsvTable) find(rgb int) consoleColor {
 	hsv := toHSV(rgb)
 	n := 7
 	l := float32(5.0)
 	for i, p := range t {
 		d := hsv.dist(p)
 		if d < l {
 			l, n = d, i
 		}
 	}
 	return color16[n]
 }
 func minmax3f(a, b, c float32) (min, max float32) {
 	if a < b {
 		if b < c {
 			return a, c
 		} else if a < c {
 			return a, b
 		} else {
 			return c, b
 		}
 	} else {
 		if a < c {
 			return b, c
 		} else if b < c {
 			return b, a
 		} else {
 			return c, a
 		}
 	}
 }
 var n256foreAttr []word
 var n256backAttr []word
 func n256setup() {
 	n256foreAttr = make([]word, 256)
 	n256backAttr = make([]word, 256)
 	t := toHSVTable(color16)
 	for i, rgb := range color256 {
 		c := t.find(rgb)
 		n256foreAttr[i] = c.foregroundAttr()
 		n256backAttr[i] = c.backgroundAttr()
 	}
 }
--- a/vendor/github.com/mattn/go-colorable/noncolorable.go
+++ b/vendor/github.com/mattn/go-colorable/noncolorable.go
@ -0,0 +1,55 @@
 package colorable
 import (
 	"bytes"
 	"io"
 )
 // NonColorable hold writer but remove escape sequence.
 type NonColorable struct {
 	out io.Writer
 }
 // NewNonColorable return new instance of Writer which remove escape sequence from Writer.
 func NewNonColorable(w io.Writer) io.Writer {
 	return &NonColorable{out: w}
 }
 // Write write data on console
 func (w *NonColorable) Write(data []byte) (n int, err error) {
 	er := bytes.NewReader(data)
 	var bw [1]byte
 loop:
 	for {
 		c1, err := er.ReadByte()
 		if err != nil {
 			break loop
 		}
 		if c1 != 0x1b {
 			bw[0] = c1
 			w.out.Write(bw[:])
 			continue
 		}
 		c2, err := er.ReadByte()
 		if err != nil {
 			break loop
 		}
 		if c2 != 0x5b {
 			continue
 		}
 		var buf bytes.Buffer
 		for {
 			c, err := er.ReadByte()
 			if err != nil {
 				break loop
 			}
 			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
 				break
 			}
 			buf.Write([]byte(string(c)))
 		}
 	}
 	return len(data), nil
 }
--- a/vendor/github.com/mattn/go-isatty/.travis.yml
+++ b/vendor/github.com/mattn/go-isatty/.travis.yml
@ -0,0 +1,9 @@
 language: go
 go:
  - tip
 before_install:
  - go get github.com/mattn/goveralls
  - go get golang.org/x/tools/cmd/cover
 script:
  - $HOME/gopath/bin/goveralls -repotoken 3gHdORO5k5ziZcWMBxnd9LrMZaJs8m9x5
--- a/vendor/github.com/mattn/go-isatty/BUILD
+++ b/vendor/github.com/mattn/go-isatty/BUILD
@ -0,0 +1,43 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
    name = "go_default_library",
    srcs = [
        "doc.go",
        "isatty_bsd.go",
        "isatty_linux.go",
        "isatty_linux_ppc64x.go",
        "isatty_others.go",
        "isatty_solaris.go",
        "isatty_windows.go",
    ],
    importmap = "k8s.io/kubernetes/vendor/github.com/mattn/go-isatty",
    importpath = "github.com/mattn/go-isatty",
    visibility = ["//visibility:public"],
    deps = select({
        "@io_bazel_rules_go//go/platform:linux_ppc64": [
            "//vendor/golang.org/x/sys/unix:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:linux_ppc64le": [
            "//vendor/golang.org/x/sys/unix:go_default_library",
        ],
        "@io_bazel_rules_go//go/platform:solaris_amd64": [
            "//vendor/golang.org/x/sys/unix:go_default_library",
        ],
        "//conditions:default": [],
    }),
 )
 filegroup(
    name = "package-srcs",
    srcs = glob(["**"]),
    tags = ["automanaged"],
    visibility = ["//visibility:private"],
 )
 filegroup(
    name = "all-srcs",
    srcs = [":package-srcs"],
    tags = ["automanaged"],
    visibility = ["//visibility:public"],
 )
--- a/vendor/github.com/mattn/go-isatty/LICENSE
+++ b/vendor/github.com/mattn/go-isatty/LICENSE
@ -0,0 +1,9 @@
 Copyright (c) Yasuhiro MATSUMOTO <mattn.jp@gmail.com>
 MIT License (Expat)
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/mattn/go-isatty/README.md
+++ b/vendor/github.com/mattn/go-isatty/README.md
@ -0,0 +1,50 @@
 # go-isatty
 [![Godoc Reference](https://godoc.org/github.com/mattn/go-isatty?status.svg)](http://godoc.org/github.com/mattn/go-isatty)
 [![Build Status](https://travis-ci.org/mattn/go-isatty.svg?branch=master)](https://travis-ci.org/mattn/go-isatty)
 [![Coverage Status](https://coveralls.io/repos/github/mattn/go-isatty/badge.svg?branch=master)](https://coveralls.io/github/mattn/go-isatty?branch=master)
 [![Go Report Card](https://goreportcard.com/badge/mattn/go-isatty)](https://goreportcard.com/report/mattn/go-isatty)
 isatty for golang
 ## Usage
 ```go
 package main
 import (
 	"fmt"
 	"github.com/mattn/go-isatty"
 	"os"
 )
 func main() {
 	if isatty.IsTerminal(os.Stdout.Fd()) {
 		fmt.Println("Is Terminal")
 	} else if isatty.IsCygwinTerminal(os.Stdout.Fd()) {
 		fmt.Println("Is Cygwin/MSYS2 Terminal")
 	} else {
 		fmt.Println("Is Not Terminal")
 	}
 }
 ```
 ## Installation
 ```
 $ go get github.com/mattn/go-isatty
 ```
 ## License
 MIT
 ## Author
 Yasuhiro Matsumoto (a.k.a mattn)
 ## Thanks
 * k-takata: base idea for IsCygwinTerminal
    https://github.com/k-takata/go-iscygpty
--- a/vendor/github.com/mattn/go-isatty/doc.go
+++ b/vendor/github.com/mattn/go-isatty/doc.go
@ -0,0 +1,2 @@
 // Package isatty implements interface to isatty
 package isatty
--- a/vendor/github.com/mattn/go-isatty/isatty_appengine.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_appengine.go
@ -0,0 +1,15 @@
 // +build appengine
 package isatty
 // IsTerminal returns true if the file descriptor is terminal which
 // is always false on on appengine classic which is a sandboxed PaaS.
 func IsTerminal(fd uintptr) bool {
 	return false
 }
 // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
 // terminal. This is also always false on this environment.
 func IsCygwinTerminal(fd uintptr) bool {
 	return false
 }
--- a/vendor/github.com/mattn/go-isatty/isatty_bsd.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_bsd.go
@ -0,0 +1,18 @@
 // +build darwin freebsd openbsd netbsd dragonfly
 // +build !appengine
 package isatty
 import (
 	"syscall"
 	"unsafe"
 )
 const ioctlReadTermios = syscall.TIOCGETA
 // IsTerminal return true if the file descriptor is terminal.
 func IsTerminal(fd uintptr) bool {
 	var termios syscall.Termios
 	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
 	return err == 0
 }
--- a/vendor/github.com/mattn/go-isatty/isatty_linux.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_linux.go
@ -0,0 +1,18 @@
 // +build linux
 // +build !appengine,!ppc64,!ppc64le
 package isatty
 import (
 	"syscall"
 	"unsafe"
 )
 const ioctlReadTermios = syscall.TCGETS
 // IsTerminal return true if the file descriptor is terminal.
 func IsTerminal(fd uintptr) bool {
 	var termios syscall.Termios
 	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
 	return err == 0
 }
--- a/vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go
@ -0,0 +1,19 @@
 // +build linux
 // +build ppc64 ppc64le
 package isatty
 import (
 	"unsafe"
 	syscall "golang.org/x/sys/unix"
 )
 const ioctlReadTermios = syscall.TCGETS
 // IsTerminal return true if the file descriptor is terminal.
 func IsTerminal(fd uintptr) bool {
 	var termios syscall.Termios
 	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
 	return err == 0
 }
--- a/vendor/github.com/mattn/go-isatty/isatty_others.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_others.go
@ -0,0 +1,10 @@
 // +build !windows
 // +build !appengine
 package isatty
 // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
 // terminal. This is also always false on this environment.
 func IsCygwinTerminal(fd uintptr) bool {
 	return false
 }
--- a/vendor/github.com/mattn/go-isatty/isatty_solaris.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_solaris.go
@ -0,0 +1,16 @@
 // +build solaris
 // +build !appengine
 package isatty
 import (
 	"golang.org/x/sys/unix"
 )
 // IsTerminal returns true if the given file descriptor is a terminal.
 // see: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libbc/libc/gen/common/isatty.c
 func IsTerminal(fd uintptr) bool {
 	var termio unix.Termio
 	err := unix.IoctlSetTermio(int(fd), unix.TCGETA, &termio)
 	return err == nil
 }
--- a/vendor/github.com/mattn/go-isatty/isatty_windows.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_windows.go
@ -0,0 +1,94 @@
 // +build windows
 // +build !appengine
 package isatty
 import (
 	"strings"
 	"syscall"
 	"unicode/utf16"
 	"unsafe"
 )
 const (
 	fileNameInfo uintptr = 2
 	fileTypePipe         = 3
 )
 var (
 	kernel32                         = syscall.NewLazyDLL("kernel32.dll")
 	procGetConsoleMode               = kernel32.NewProc("GetConsoleMode")
 	procGetFileInformationByHandleEx = kernel32.NewProc("GetFileInformationByHandleEx")
 	procGetFileType                  = kernel32.NewProc("GetFileType")
 )
 func init() {
 	// Check if GetFileInformationByHandleEx is available.
 	if procGetFileInformationByHandleEx.Find() != nil {
 		procGetFileInformationByHandleEx = nil
 	}
 }
 // IsTerminal return true if the file descriptor is terminal.
 func IsTerminal(fd uintptr) bool {
 	var st uint32
 	r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fd, uintptr(unsafe.Pointer(&st)), 0)
 	return r != 0 && e == 0
 }
 // Check pipe name is used for cygwin/msys2 pty.
 // Cygwin/MSYS2 PTY has a name like:
 //   \{cygwin,msys}-XXXXXXXXXXXXXXXX-ptyN-{from,to}-master
 func isCygwinPipeName(name string) bool {
 	token := strings.Split(name, "-")
 	if len(token) < 5 {
 		return false
 	}
 	if token[0] != `\msys` && token[0] != `\cygwin` {
 		return false
 	}
 	if token[1] == "" {
 		return false
 	}
 	if !strings.HasPrefix(token[2], "pty") {
 		return false
 	}
 	if token[3] != `from` && token[3] != `to` {
 		return false
 	}
 	if token[4] != "master" {
 		return false
 	}
 	return true
 }
 // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
 // terminal.
 func IsCygwinTerminal(fd uintptr) bool {
 	if procGetFileInformationByHandleEx == nil {
 		return false
 	}
 	// Cygwin/msys's pty is a pipe.
 	ft, _, e := syscall.Syscall(procGetFileType.Addr(), 1, fd, 0, 0)
 	if ft != fileTypePipe || e != 0 {
 		return false
 	}
 	var buf [2 + syscall.MAX_PATH]uint16
 	r, _, e := syscall.Syscall6(procGetFileInformationByHandleEx.Addr(),
 		4, fd, fileNameInfo, uintptr(unsafe.Pointer(&buf)),
 		uintptr(len(buf)*2), 0, 0)
 	if r == 0 || e != 0 {
 		return false
 	}
 	l := *(*uint32)(unsafe.Pointer(&buf))
 	return isCygwinPipeName(string(utf16.Decode(buf[2 : 2+l/2])))
 }
--- a/vendor/golang.org/x/sync/AUTHORS
+++ b/vendor/golang.org/x/sync/AUTHORS
@ -0,0 +1,3 @@
 # This source code refers to The Go Authors for copyright purposes.
 # The master list of authors is in the main Go distribution,
 # visible at http://tip.golang.org/AUTHORS.
--- a/vendor/golang.org/x/sync/CONTRIBUTORS
+++ b/vendor/golang.org/x/sync/CONTRIBUTORS
@ -0,0 +1,3 @@
 # This source code was written by the Go contributors.
 # The master list of contributors is in the main Go distribution,
 # visible at http://tip.golang.org/CONTRIBUTORS.
--- a/vendor/golang.org/x/sync/LICENSE
+++ b/vendor/golang.org/x/sync/LICENSE
@ -0,0 +1,27 @@
 Copyright (c) 2009 The Go Authors. All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
   * Redistributions of source code must retain the above copyright
 notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
   * Neither the name of Google Inc. nor the names of its
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/vendor/golang.org/x/sync/PATENTS
+++ b/vendor/golang.org/x/sync/PATENTS
@ -0,0 +1,22 @@
 Additional IP Rights Grant (Patents)
 "This implementation" means the copyrightable works distributed by
 Google as part of the Go project.
 Google hereby grants to You a perpetual, worldwide, non-exclusive,
 no-charge, royalty-free, irrevocable (except as stated in this section)
 patent license to make, have made, use, offer to sell, sell, import,
 transfer and otherwise run, modify and propagate the contents of this
 implementation of Go, where such license applies only to those patent
 claims, both currently owned or controlled by Google and acquired in
 the future, licensable by Google that are necessarily infringed by this
 implementation of Go.  This grant does not include claims that would be
 infringed only as a consequence of further modification of this
 implementation.  If you or your agent or exclusive licensee institute or
 order or agree to the institution of patent litigation against any
 entity (including a cross-claim or counterclaim in a lawsuit) alleging
 that this implementation of Go or any code incorporated within this
 implementation of Go constitutes direct or contributory patent
 infringement, or inducement of patent infringement, then any patent
 rights granted to you under this License for this implementation of Go
 shall terminate as of the date such litigation is filed.
--- a/vendor/github.com/jstemmer/go-junit-report/parser/BUILD
+++ b/vendor/github.com/jstemmer/go-junit-report/parser/BUILD
@ -2,9 +2,9 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
    name = "go_default_library",
-    srcs = ["parser.go"],
+    srcs = ["errgroup.go"],
-    importmap = "k8s.io/kubernetes/vendor/github.com/jstemmer/go-junit-report/parser",
+    importmap = "k8s.io/kubernetes/vendor/golang.org/x/sync/errgroup",
-    importpath = "github.com/jstemmer/go-junit-report/parser",
+    importpath = "golang.org/x/sync/errgroup",
    visibility = ["//visibility:public"],
 )
--- a/vendor/golang.org/x/sync/errgroup/errgroup.go
+++ b/vendor/golang.org/x/sync/errgroup/errgroup.go
@ -0,0 +1,66 @@
 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 // Package errgroup provides synchronization, error propagation, and Context
 // cancelation for groups of goroutines working on subtasks of a common task.
 package errgroup
 import (
 	"context"
 	"sync"
 )
 // A Group is a collection of goroutines working on subtasks that are part of
 // the same overall task.
 //
 // A zero Group is valid and does not cancel on error.
 type Group struct {
 	cancel func()
 	wg sync.WaitGroup
 	errOnce sync.Once
 	err     error
 }
 // WithContext returns a new Group and an associated Context derived from ctx.
 //
 // The derived Context is canceled the first time a function passed to Go
 // returns a non-nil error or the first time Wait returns, whichever occurs
 // first.
 func WithContext(ctx context.Context) (*Group, context.Context) {
 	ctx, cancel := context.WithCancel(ctx)
 	return &Group{cancel: cancel}, ctx
 }
 // Wait blocks until all function calls from the Go method have returned, then
 // returns the first non-nil error (if any) from them.
 func (g *Group) Wait() error {
 	g.wg.Wait()
 	if g.cancel != nil {
 		g.cancel()
 	}
 	return g.err
 }
 // Go calls the given function in a new goroutine.
 //
 // The first call to return a non-nil error cancels the group; its error will be
 // returned by Wait.
 func (g *Group) Go(f func() error) {
 	g.wg.Add(1)
 	go func() {
 		defer g.wg.Done()
 		if err := f(); err != nil {
 			g.errOnce.Do(func() {
 				g.err = err
 				if g.cancel != nil {
 					g.cancel()
 				}
 			})
 		}
 	}()
 }
--- a/vendor/gotest.tools/.codecov.yml
+++ b/vendor/gotest.tools/.codecov.yml
@ -0,0 +1,8 @@
 coverage:
  status:
    project:
      default:
        threshold: 2
    patch:
      default:
        threshold: 20
--- a/vendor/gotest.tools/.gitignore
+++ b/vendor/gotest.tools/.gitignore
@ -0,0 +1,5 @@
 vendor/
 .dobi/
 Gopkg.lock
 .depsources
 dist/
--- a/vendor/gotest.tools/BUILD
+++ b/vendor/gotest.tools/BUILD
@ -0,0 +1,26 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
    name = "go_default_library",
    srcs = ["pkg.go"],
    importmap = "k8s.io/kubernetes/vendor/gotest.tools",
    importpath = "gotest.tools",
    visibility = ["//visibility:public"],
 )
 filegroup(
    name = "package-srcs",
    srcs = glob(["**"]),
    tags = ["automanaged"],
    visibility = ["//visibility:private"],
 )
 filegroup(
    name = "all-srcs",
    srcs = [
        ":package-srcs",
        "//vendor/gotest.tools/gotestsum:all-srcs",
    ],
    tags = ["automanaged"],
    visibility = ["//visibility:public"],
 )
--- a/vendor/gotest.tools/Gopkg.toml
+++ b/vendor/gotest.tools/Gopkg.toml
@ -0,0 +1,16 @@
 [[constraint]]
  name = "github.com/pkg/errors"
  version = "0.8.0"
 [[constraint]]
  name = "github.com/spf13/pflag"
  version = "1.0.0"
 [[constraint]]
  name = "github.com/google/go-cmp"
  version = "0.2.0"
 [[constraint]]
  branch = "master"
  name = "golang.org/x/tools"
--- a/vendor/gotest.tools/LICENSE
+++ b/vendor/gotest.tools/LICENSE
@ -0,0 +1,13 @@
 Copyright 2018 gotest.tools authors
 Licensed 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.
--- a/vendor/gotest.tools/README.md
+++ b/vendor/gotest.tools/README.md
@ -0,0 +1,31 @@
 # gotest.tools
 A collection of packages to augment `testing` and support common patterns.
 [![GoDoc](https://godoc.org/gotest.tools?status.svg)](https://godoc.org/gotest.tools)
 [![CircleCI](https://circleci.com/gh/gotestyourself/gotest.tools/tree/master.svg?style=shield)](https://circleci.com/gh/gotestyourself/gotest.tools/tree/master)
 [![Go Reportcard](https://goreportcard.com/badge/gotest.tools)](https://goreportcard.com/report/gotest.tools)
 ## Packages
 * [assert](http://godoc.org/gotest.tools/assert) -
  compare values and fail the test when a comparison fails
 * [env](http://godoc.org/gotest.tools/env) -
  test code which uses environment variables
 * [fs](http://godoc.org/gotest.tools/fs) -
  create temporary files and compare a filesystem tree to an expected value
 * [golden](http://godoc.org/gotest.tools/golden) -
  compare large multi-line strings against values frozen in golden files
 * [icmd](http://godoc.org/gotest.tools/icmd) -
  execute binaries and test the output
 * [poll](http://godoc.org/gotest.tools/poll) -
  test asynchronous code by polling until a desired state is reached
 * [skip](http://godoc.org/gotest.tools/skip) -
  skip a test and print the source code of the condition used to skip the test
 ## Related
 * [gotest.tools/gotestsum](https://github.com/gotestyourself/gotestsum) - go test runner with custom output
 * [maxbrunsfeld/counterfeiter](https://github.com/maxbrunsfeld/counterfeiter) - generate fakes for interfaces
 * [jonboulle/clockwork](https://github.com/jonboulle/clockwork) - a fake clock for testing code that uses `time`
--- a/vendor/gotest.tools/appveyor.yml
+++ b/vendor/gotest.tools/appveyor.yml
@ -0,0 +1,28 @@
 version: "{build}"
 image: Visual Studio 2017
 clone_folder: c:\gopath\src\gotest.tools
 environment:
  PATH: c:\go110\bin;%PATH%
  GOROOT: c:\go110
  GOPATH: c:\gopath
  DEPVERSION: v0.4.1
 init:
  - git config --global core.symlinks true
 install:
  - go version
  - go env
 deploy: false
 build_script:
  - appveyor DownloadFile https://github.com/golang/dep/releases/download/%DEPVERSION%/dep-windows-amd64.exe
  - appveyor DownloadFile https://github.com/gotestyourself/gotestsum/releases/download/v0.3.0/gotestsum_0.3.0_windows_amd64.tar.gz
  - tar -xzf gotestsum_0.3.0_windows_amd64.tar.gz
  - dep-windows-amd64.exe ensure
 test_script:
  - gotestsum
--- a/vendor/gotest.tools/dobi.yaml
+++ b/vendor/gotest.tools/dobi.yaml
@ -0,0 +1,56 @@
 meta:
  project: gotesttools
 mount=source:
  bind: .
  path: /go/src/gotest.tools
 mount=depsources:
 bind: ./.depsources
 path: /go/pkg/dep/sources
 image=builder:
  image: gotesttools-dev
  context: dobifiles/
  dockerfile: Dockerfile
  args:
    GOLANG_VERSION: '{env.GOLANG_VERSION:}' 
 image=linter:
  image: gotesttools-lint
  context: dobifiles/
  dockerfile: Dockerfile.lint
 job=shell:
  use: builder
  mounts: [source, depsources]
  interactive: true
  command: sh
 job=watch:
  use: builder
  mounts: [source]
  interactive: true
  command: |
      filewatcher -x vendor gotestsum -- -test.timeout 10s
  env:
    - 'GOTESTSUM_FORMAT=short-verbose'
    - 'GOTESTTOOLS_DEBUG={env.GOTESTTOOLS_DEBUG:}'
 job=test-unit:
  use: builder
  mounts: [source]
  interactive: true
  command: scripts/test-unit
 job=deps:
  use: builder
  mounts: [source, depsources]
  command: dep ensure
 job=lint:
  use: linter
  mounts: [source]
 alias=test:
  tasks: [test-unit]
--- a/vendor/gotest.tools/gometalinter.json
+++ b/vendor/gotest.tools/gometalinter.json
@ -0,0 +1,31 @@
 {
  "Vendor": true,
  "Deadline": "2m",
  "Sort": ["linter", "severity", "path"],
  "Exclude": [
    "example_test\\.go",
    "assert/cmd/gty-migrate-from-testify/testdata",
    "internal/difflib/difflib.go"
  ],
  "Enable": [
    "deadcode",
    "errcheck",
    "gocyclo",
    "gofmt",
    "goimports",
    "golint",
    "gosimple",
    "ineffassign",
    "interfacer",
    "lll",
    "misspell",
    "unconvert",
    "unparam",
    "unused",
    "vet"
  ],
  "Cyclo": 10,
  "LineLength": 100
 }
--- a/vendor/gotest.tools/gotestsum/.gitignore
+++ b/vendor/gotest.tools/gotestsum/.gitignore
@ -0,0 +1,5 @@
 vendor/
 .dobi/
 .depsources
 dist/
 junit.xml
--- a/vendor/gotest.tools/gotestsum/.golangci.yml
+++ b/vendor/gotest.tools/gotestsum/.golangci.yml
@ -0,0 +1,39 @@
 linters-settings:
  gocyclo:
    min-complexity: 10
  goconst:
    min-len: 2
    min-occurrences: 4
  lll:
    line-length: 100
  gocritic:
    enabled-tags:
      - diagnostic
      - performance
      - style
      - experimental
    disabled-checks:
      - importShadow
      - paramTypeCombine
      - commentFormatting # https://github.com/go-critic/go-critic/issues/755
      - unnamedResult
    settings:
      hugeParam:
        sizeThreshold: 256
 issues:
  exclude-use-default: false
  exclude:
    # unparam
    - 'result .* is always'
    - 'always receives'
 linters:
  enable-all: true
  disable:
    - dupl
    - gochecknoglobals
    - gochecknoinits
    - gosec
    - scopelint
    - maligned
--- a/vendor/gotest.tools/gotestsum/.goreleaser.yml
+++ b/vendor/gotest.tools/gotestsum/.goreleaser.yml
@ -0,0 +1,19 @@
 project_name: gotestsum
 release:
  github:
    owner: gotestyourself
    name: gotestsum
 builds:
  - binary: gotestsum
    goos:
      - darwin
      - windows
      - linux
    goarch: [amd64]
    env: [CGO_ENABLED=0]
 checksum:
  name_template: '{{ .ProjectName }}-{{ .Version }}-checksums.txt'
--- a/vendor/gotest.tools/gotestsum/BUILD
+++ b/vendor/gotest.tools/gotestsum/BUILD
@ -0,0 +1,47 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library")
 go_library(
    name = "go_default_library",
    srcs = [
        "exitcode.go",
        "flags.go",
        "handler.go",
        "main.go",
    ],
    importmap = "k8s.io/kubernetes/vendor/gotest.tools/gotestsum",
    importpath = "gotest.tools/gotestsum",
    visibility = ["//visibility:private"],
    deps = [
        "//vendor/github.com/fatih/color:go_default_library",
        "//vendor/github.com/pkg/errors:go_default_library",
        "//vendor/github.com/sirupsen/logrus:go_default_library",
        "//vendor/github.com/spf13/pflag:go_default_library",
        "//vendor/gotest.tools/gotestsum/internal/junitxml:go_default_library",
        "//vendor/gotest.tools/gotestsum/testjson:go_default_library",
    ],
 )
 go_binary(
    name = "gotestsum",
    embed = [":go_default_library"],
    tags = ["manual"],
    visibility = ["//visibility:public"],
 )
 filegroup(
    name = "package-srcs",
    srcs = glob(["**"]),
    tags = ["automanaged"],
    visibility = ["//visibility:private"],
 )
 filegroup(
    name = "all-srcs",
    srcs = [
        ":package-srcs",
        "//vendor/gotest.tools/gotestsum/internal/junitxml:all-srcs",
        "//vendor/gotest.tools/gotestsum/testjson:all-srcs",
    ],
    tags = ["automanaged"],
    visibility = ["//visibility:public"],
 )
--- a/vendor/gotest.tools/gotestsum/Gopkg.lock
+++ b/vendor/gotest.tools/gotestsum/Gopkg.lock
@ -0,0 +1,105 @@
 # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 [[projects]]
  name = "github.com/fatih/color"
  packages = ["."]
  revision = "507f6050b8568533fb3f5504de8e5205fa62a114"
  version = "v1.6.0"
 [[projects]]
  name = "github.com/google/go-cmp"
  packages = [
    "cmp",
    "cmp/internal/diff",
    "cmp/internal/function",
    "cmp/internal/value"
  ]
  revision = "3af367b6b30c263d47e8895973edcca9a49cf029"
  version = "v0.2.0"
 [[projects]]
  name = "github.com/jonboulle/clockwork"
  packages = ["."]
  revision = "2eee05ed794112d45db504eb05aa693efd2b8b09"
  version = "v0.1.0"
 [[projects]]
  name = "github.com/mattn/go-colorable"
  packages = ["."]
  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
  version = "v0.0.9"
 [[projects]]
  name = "github.com/mattn/go-isatty"
  packages = ["."]
  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
  version = "v0.0.3"
 [[projects]]
  name = "github.com/pkg/errors"
  packages = ["."]
  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
  version = "v0.8.0"
 [[projects]]
  name = "github.com/sirupsen/logrus"
  packages = ["."]
  revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
  version = "v1.0.5"
 [[projects]]
  name = "github.com/spf13/pflag"
  packages = ["."]
  revision = "583c0c0531f06d5278b7d917446061adc344b5cd"
  version = "v1.0.1"
 [[projects]]
  branch = "master"
  name = "golang.org/x/crypto"
  packages = ["ssh/terminal"]
  revision = "b49d69b5da943f7ef3c9cf91c8777c1f78a0cc3c"
 [[projects]]
  branch = "master"
  name = "golang.org/x/net"
  packages = ["context"]
  revision = "c10e9556a7bc0e7c942242b606f0acf024ad5d6a"
 [[projects]]
  branch = "master"
  name = "golang.org/x/sync"
  packages = ["errgroup"]
  revision = "1d60e4601c6fd243af51cc01ddf169918a5407ca"
 [[projects]]
  branch = "master"
  name = "golang.org/x/sys"
  packages = [
    "unix",
    "windows"
  ]
  revision = "cbbc999da32df943dac6cd71eb3ee39e1d7838b9"
 [[projects]]
  name = "gotest.tools"
  packages = [
    "assert",
    "assert/cmp",
    "assert/opt",
    "env",
    "golden",
    "internal/difflib",
    "internal/format",
    "internal/source",
    "x/subtest"
  ]
  revision = "14eefd8766a1439cddfc295ecf6327cb422b4bb2"
  version = "v2.0.0"
 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
  inputs-digest = "552c8a2217a39dc7af8c93bc05a914c24c4b1ce338df4dfd972f9e436f2ef3bb"
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/vendor/gotest.tools/gotestsum/Gopkg.toml
+++ b/vendor/gotest.tools/gotestsum/Gopkg.toml
@ -0,0 +1,32 @@
 [prune]
  non-go = true
  go-tests = true
  unused-packages = true
 [[constraint]]
  name = "github.com/google/go-cmp"
  version = "0.2.0"
 [[constraint]]
  name = "github.com/jonboulle/clockwork"
  version = "0.1.0"
 [[constraint]]
  name = "github.com/pkg/errors"
  version = "0.8.0"
 [[constraint]]
  name = "github.com/spf13/pflag"
  version = "1.0.0"
 [[constraint]]
  name = "github.com/sirupsen/logrus"
  version = "1.0.5"
 [[constraint]]
  name = "gotest.tools"
  version = "2.0.0"
 [[constraint]]
  name = "github.com/fatih/color"
  version = "1.6.0"
--- a/vendor/gotest.tools/gotestsum/LICENSE
+++ b/vendor/gotest.tools/gotestsum/LICENSE
@ -0,0 +1,202 @@
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   APPENDIX: How to apply the Apache License to your work.
      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.
   Copyright [yyyy] [name of copyright owner]
   Licensed 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.
--- a/vendor/gotest.tools/gotestsum/README.md
+++ b/vendor/gotest.tools/gotestsum/README.md
@ -0,0 +1,154 @@
 # gotestsum
 `gotestsum` runs tests, prints friendly test output and a summary of the test run.  Requires Go 1.10+.
 ## Install
 Download a binary from [releases](https://github.com/gotestyourself/gotestsum/releases), or get the
 source with `go get gotest.tools/gotestsum` (you may need to run `dep ensure`).
 ## Demo
 ![Demo](https://raw.githubusercontent.com/gotestyourself/gotestsum/master/docs/demo.gif)
 ## Docs
 [![GoDoc](https://godoc.org/gotest.tools/gotestsum?status.svg)](https://godoc.org/gotest.tools/gotestsum)
 [![CircleCI](https://circleci.com/gh/gotestyourself/gotestsum/tree/master.svg?style=shield)](https://circleci.com/gh/gotestyourself/gotestsum/tree/master)
 [![Go Reportcard](https://goreportcard.com/badge/gotest.tools/gotestsum)](https://goreportcard.com/report/gotest.tools/gotestsum)
 `gotestsum` works by running `go test --json ./...` and reading the JSON
 output.
 ### TOC
 - [Format](#format)
 - [Summary](#summary)
 - [JUnit XML](#junit-xml)
 - [JSON file](#json-file-output)
 - [Setting go test flags and using custom commands](#custom-go-test-command)
 ### Format
 Set a format with the `--format` flag or the `GOTESTSUM_FORMAT` environment
 variable.
 ```
 gotestsum --format short-verbose
 ```
 Supported formats:
 * `dots` - output one character per test.
 * `short` (default) - output a line for each test package.
 * `standard-quiet` - the default `go test` format.
 * `short-verbose` - output a line for each test and package.
 * `standard-verbose` - the standard `go test -v` format.
 Have a suggestion for some other format? Please open an issue!
 ### Summary
 A summary of the test run is printed after the test output.
 ```
 DONE 101 tests[, 3 skipped][, 2 failures][, 1 error] in 0.103s
 ```
 The summary includes:
 * A count of: tests run, tests skipped, tests failed, and package build errors.
 * Elapsed time including time to build.
 * Test output of all failed and skipped tests, and any package build errors.
 To disable parts of the summary use `--no-summary section`.
 Example: hide skipped tests in the summary
 ```
 gotestsum --no-summary=skipped
 ```
 Example: hide failed and skipped
 ```
 gotestsum --no-summary=skipped,failed
 ```
 Example: hide output in the summary, only print names of failed and skipped tests
 and errors
 ```
 gotestsum --no-summary=output
 ```
 ### JUnit XML
 When the `--junitfile` flag or `GOTESTSUM_JUNITFILE` environment variable are set
 to a file path `gotestsum` will write a test report, in JUnit XML format, to the file.
 This file can be used to integrate with CI systems.
 ```
 gotestsum --junitfile unit-tests.xml
 ```
 ### JSON file output
 When the `--jsonfile` flag or `GOTESTSUM_JSONFILE` environment variable are set
 to a file path `gotestsum` will write a line-delimited JSON file with all the
 [test2json](https://golang.org/cmd/test2json/#hdr-Output_Format)
 output that was written by `go test --json`. This file can be used to compare test
 runs, or find flaky tests.
 ```
 gotestsum --jsonfile test-output.log
 ```
 ### Custom `go test` command
 By default `gotestsum` runs tests using the command `go test --json ./...`. You
 can change the command with positional arguments after a `--`. You can change just the
 test directory value (which defaults to `./...`) by setting the `TEST_DIRECTORY`
 environment variable.
 You can use `--debug` to echo the command before it is run.
 Example: set build tags
 ```
 gotestsum -- -tags=integration ./...
 ```
 Example: run tests in a single package
 ```
 gotestsum -- ./io/http
 ```
 Example: enable coverage
 ```
 gotestsum -- -coverprofile=cover.out ./...
 ```
 Example: run a script instead of `go test`
 ```
 gotestsum --raw-command -- ./scripts/run_tests.sh
 ```
 Note: when using `--raw-command` you must ensure that the stdout produced by
 the script only contains the `test2json` output. Any stderr produced by the script
 will be considered an error (this behaviour is necessary because package build errors
 are only reported by writting to stderr, not the `test2json` stdout). Any stderr
 produced by tests is not considered an error (it will be in the `test2json` stdout).
 Example: using `TEST_DIRECTORY`
 ```
 TEST_DIRECTORY=./io/http gotestsum
 ```
 ### Run tests when a file is modified
 [filewatcher](https://github.com/dnephin/filewatcher) will automatically set the
 `TEST_DIRECTORY` environment variable which makes it easy to integrate
 `gotestsum`.
 Example: run tests for a package when any file in that package is saved
 ```
 filewatcher gotestsum
 ```
 ## Thanks
 This package is heavily influenced by the [pytest](https://docs.pytest.org) test runner for `python`.
--- a/vendor/gotest.tools/gotestsum/dobi.yaml
+++ b/vendor/gotest.tools/gotestsum/dobi.yaml
@ -0,0 +1,56 @@
 meta:
  project: gotestsum
 mount=source:
  bind: .
  path: /go/src/gotest.tools/gotestsum
 mount=buildcache:
  bind: ~/.cache/go-build
  path: /root/.cache/go-build
 mount=modcache:
  bind: ~/go/pkg/mod
  path: /go/pkg/mod
 image=builder:
  image: gotestsum-dev
  context: dobifiles/
  dockerfile: Dockerfile
  target: dev
  args:
    GOLANG_VERSION: '{env.GOLANG_VERSION:}' 
 job=shell:
  use: builder
  mounts: [source, buildcache, modcache]
  interactive: true
  command: sh
 job=watch:
  use: builder
  mounts: [source, buildcache, modcache]
  interactive: true
  command: |
      filewatcher -x vendor ./dist/gotestsum -- -test.timeout 10s
  env: ['GOTESTSUM_FORMAT=short-verbose']
  depends: [binary]
 job=test-unit:
  use: builder
  mounts: [source, buildcache, modcache]
  interactive: true
  command: scripts/test-unit
 job=lint:
  use: builder
  mounts: [source, buildcache, modcache]
  command: golangci-lint run
 job=binary:
  use: builder
  mounts: [source, buildcache, modcache]
  command: bash -c 'mkdir -p dist; go build -o dist/gotestsum .'
 alias=test:
  tasks: [test-unit]
--- a/vendor/gotest.tools/gotestsum/exitcode.go
+++ b/vendor/gotest.tools/gotestsum/exitcode.go
@ -0,0 +1,35 @@
 package main
 import (
 	"os/exec"
 	"syscall"
 	"github.com/pkg/errors"
 )
 // Copied from gotestyourself/icmd
 // GetExitCode returns the ExitStatus of a process from the error returned by
 // exec.Run(). If the exit status is not available an error is returned.
 func GetExitCode(err error) (int, error) {
 	if exiterr, ok := err.(*exec.ExitError); ok {
 		if procExit, ok := exiterr.Sys().(syscall.WaitStatus); ok {
 			return procExit.ExitStatus(), nil
 		}
 	}
 	return 0, errors.Wrap(err, "failed to get exit code")
 }
 // ExitCodeWithDefault returns ExitStatus of a process from the error returned by
 // exec.Run(). If the exit status is not available return a default of 127.
 func ExitCodeWithDefault(err error) int {
 	if err == nil {
 		return 0
 	}
 	exitCode, exiterr := GetExitCode(err)
 	if exiterr != nil {
 		// we've failed to retrieve exit code, so we set it to 127
 		return 127
 	}
 	return exitCode
 }
--- a/vendor/gotest.tools/gotestsum/flags.go
+++ b/vendor/gotest.tools/gotestsum/flags.go
@ -0,0 +1,49 @@
 package main
 import (
 	"encoding/csv"
 	"strings"
 	"github.com/pkg/errors"
 	"gotest.tools/gotestsum/testjson"
 )
 type noSummaryValue struct {
 	value testjson.Summary
 }
 func newNoSummaryValue() *noSummaryValue {
 	return &noSummaryValue{value: testjson.SummarizeAll}
 }
 func readAsCSV(val string) ([]string, error) {
 	if val == "" {
 		return nil, nil
 	}
 	return csv.NewReader(strings.NewReader(val)).Read()
 }
 func (s *noSummaryValue) Set(val string) error {
 	v, err := readAsCSV(val)
 	if err != nil {
 		return err
 	}
 	for _, item := range v {
 		summary, ok := testjson.NewSummary(item)
 		if !ok {
 			return errors.Errorf("value must be one or more of: %s",
 				testjson.SummarizeAll.String())
 		}
 		s.value -= summary
 	}
 	return nil
 }
 func (s *noSummaryValue) Type() string {
 	return "summary"
 }
 func (s *noSummaryValue) String() string {
 	// flip all the bits, since the flag value is the negative of what is stored
 	return (testjson.SummarizeAll ^ s.value).String()
 }
--- a/vendor/gotest.tools/gotestsum/go.mod
+++ b/vendor/gotest.tools/gotestsum/go.mod
@ -0,0 +1,21 @@
 module gotest.tools/gotestsum
 require (
 	github.com/fatih/color v1.6.0
 	github.com/google/go-cmp v0.2.0
 	github.com/jonboulle/clockwork v0.1.0
 	github.com/mattn/go-colorable v0.0.9 // indirect
 	github.com/mattn/go-isatty v0.0.3 // indirect
 	github.com/onsi/ginkgo v1.8.0 // indirect
 	github.com/onsi/gomega v1.4.3 // indirect
 	github.com/pkg/errors v0.8.0
 	github.com/sirupsen/logrus v1.0.5
 	github.com/spf13/pflag v1.0.1
 	github.com/stretchr/testify v1.3.0 // indirect
 	golang.org/x/crypto v0.0.0-20180426230345-b49d69b5da94 // indirect
 	golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc // indirect
 	golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f
 	gopkg.in/airbrake/gobrake.v2 v2.0.9 // indirect
 	gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2 // indirect
 	gotest.tools v2.1.0+incompatible
 )
--- a/vendor/gotest.tools/gotestsum/go.sum
+++ b/vendor/gotest.tools/gotestsum/go.sum
@ -0,0 +1,59 @@
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fatih/color v1.6.0 h1:66qjqZk8kalYAvDRtM1AdAJQI0tj4Wrue3Eq3B3pmFU=
 github.com/fatih/color v1.6.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/jonboulle/clockwork v0.1.0 h1:VKV+ZcuP6l3yW9doeqz6ziZGgcynBVQO+obU0+0hcPo=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.8.0 h1:VkHVNpR4iVnU8XQR6DBm8BqYjN7CRzw+xKUbVVbbW9w=
 github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/sirupsen/logrus v1.0.5 h1:8c8b5uO0zS4X6RPl/sd1ENwSkIc0/H2PaHxE3udaE8I=
 github.com/sirupsen/logrus v1.0.5/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
 github.com/spf13/pflag v1.0.1 h1:aCvUg6QPl3ibpQUxyLkrEkCHtPqYJL4x9AuhqVqFis4=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 golang.org/x/crypto v0.0.0-20180426230345-b49d69b5da94 h1:m5xBqfQdnzv6XuV/pJizrLOwUoGzyn1J249cA0cKL4o=
 golang.org/x/crypto v0.0.0-20180426230345-b49d69b5da94/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc h1:ZMCWScCvS2fUVFw8LOpxyUUW5qiviqr4Dg5NdjLeiLU=
 golang.org/x/net v0.0.0-20181102091132-c10e9556a7bc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 gopkg.in/airbrake/gobrake.v2 v2.0.9 h1:7z2uVWwn7oVeeugY1DtlPAy5H+KYgB1KeKTnqjNatLo=
 gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2 h1:OAj3g0cR6Dx/R07QgQe8wkA9RNjB2u4i700xBkIT4e0=
 gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gotest.tools v2.1.0+incompatible h1:5USw7CrJBYKqjg9R7QlA6jzqZKEAtvW82aNmsxxGPxw=
 gotest.tools v2.1.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
--- a/vendor/gotest.tools/gotestsum/handler.go
+++ b/vendor/gotest.tools/gotestsum/handler.go
@ -0,0 +1,87 @@
 package main
 import (
 	"io"
 	"os"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 	"gotest.tools/gotestsum/internal/junitxml"
 	"gotest.tools/gotestsum/testjson"
 )
 type eventHandler struct {
 	formatter testjson.EventFormatter
 	out       io.Writer
 	err       io.Writer
 	jsonFile  io.WriteCloser
 }
 func (h *eventHandler) Err(text string) error {
 	_, err := h.err.Write([]byte(text + "\n"))
 	return err
 }
 func (h *eventHandler) Event(event testjson.TestEvent, execution *testjson.Execution) error {
 	if h.jsonFile != nil {
 		_, err := h.jsonFile.Write(append(event.Bytes(), '\n'))
 		if err != nil {
 			return errors.Wrap(err, "failed to write JSON file")
 		}
 	}
 	line, err := h.formatter(event, execution)
 	if err != nil {
 		return errors.Wrap(err, "failed to format event")
 	}
 	_, err = h.out.Write([]byte(line))
 	return errors.Wrap(err, "failed to write event")
 }
 func (h *eventHandler) Close() error {
 	if h.jsonFile != nil {
 		if err := h.jsonFile.Close(); err != nil {
 			log.WithError(err).Error("failed to close JSON file")
 		}
 	}
 	return nil
 }
 var _ testjson.EventHandler = &eventHandler{}
 func newEventHandler(opts *options, wout io.Writer, werr io.Writer) (*eventHandler, error) {
 	formatter := testjson.NewEventFormatter(opts.format)
 	if formatter == nil {
 		return nil, errors.Errorf("unknown format %s", opts.format)
 	}
 	handler := &eventHandler{
 		formatter: formatter,
 		out:       wout,
 		err:       werr,
 	}
 	var err error
 	if opts.jsonFile != "" {
 		handler.jsonFile, err = os.Create(opts.jsonFile)
 		if err != nil {
 			return handler, errors.Wrap(err, "failed to open JSON file")
 		}
 	}
 	return handler, nil
 }
 func writeJUnitFile(filename string, execution *testjson.Execution) error {
 	if filename == "" {
 		return nil
 	}
 	junitFile, err := os.Create(filename)
 	if err != nil {
 		return errors.Wrap(err, "failed to open JUnit file")
 	}
 	defer func() {
 		if err := junitFile.Close(); err != nil {
 			log.WithError(err).Error("failed to close JUnit file")
 		}
 	}()
 	return junitxml.Write(junitFile, execution)
 }
--- a/vendor/gotest.tools/gotestsum/internal/junitxml/BUILD
+++ b/vendor/gotest.tools/gotestsum/internal/junitxml/BUILD
@ -0,0 +1,28 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
    name = "go_default_library",
    srcs = ["report.go"],
    importmap = "k8s.io/kubernetes/vendor/gotest.tools/gotestsum/internal/junitxml",
    importpath = "gotest.tools/gotestsum/internal/junitxml",
    visibility = ["//vendor/gotest.tools/gotestsum:__subpackages__"],
    deps = [
        "//vendor/github.com/pkg/errors:go_default_library",
        "//vendor/github.com/sirupsen/logrus:go_default_library",
        "//vendor/gotest.tools/gotestsum/testjson:go_default_library",
    ],
 )
 filegroup(
    name = "package-srcs",
    srcs = glob(["**"]),
    tags = ["automanaged"],
    visibility = ["//visibility:private"],
 )
 filegroup(
    name = "all-srcs",
    srcs = [":package-srcs"],
    tags = ["automanaged"],
    visibility = ["//visibility:public"],
 )
--- a/vendor/gotest.tools/gotestsum/internal/junitxml/report.go
+++ b/vendor/gotest.tools/gotestsum/internal/junitxml/report.go
@ -0,0 +1,173 @@
 /*Package junitxml creates a JUnit XML report from a testjson.Execution.
 */
 package junitxml
 import (
 	"encoding/xml"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
 	"strings"
 	"time"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"gotest.tools/gotestsum/testjson"
 )
 // JUnitTestSuites is a collection of JUnit test suites.
 type JUnitTestSuites struct {
 	XMLName xml.Name `xml:"testsuites"`
 	Suites  []JUnitTestSuite
 }
 // JUnitTestSuite is a single JUnit test suite which may contain many
 // testcases.
 type JUnitTestSuite struct {
 	XMLName    xml.Name        `xml:"testsuite"`
 	Tests      int             `xml:"tests,attr"`
 	Failures   int             `xml:"failures,attr"`
 	Time       string          `xml:"time,attr"`
 	Name       string          `xml:"name,attr"`
 	Properties []JUnitProperty `xml:"properties>property,omitempty"`
 	TestCases  []JUnitTestCase
 }
 // JUnitTestCase is a single test case with its result.
 type JUnitTestCase struct {
 	XMLName     xml.Name          `xml:"testcase"`
 	Classname   string            `xml:"classname,attr"`
 	Name        string            `xml:"name,attr"`
 	Time        string            `xml:"time,attr"`
 	SkipMessage *JUnitSkipMessage `xml:"skipped,omitempty"`
 	Failure     *JUnitFailure     `xml:"failure,omitempty"`
 }
 // JUnitSkipMessage contains the reason why a testcase was skipped.
 type JUnitSkipMessage struct {
 	Message string `xml:"message,attr"`
 }
 // JUnitProperty represents a key/value pair used to define properties.
 type JUnitProperty struct {
 	Name  string `xml:"name,attr"`
 	Value string `xml:"value,attr"`
 }
 // JUnitFailure contains data related to a failed test.
 type JUnitFailure struct {
 	Message  string `xml:"message,attr"`
 	Type     string `xml:"type,attr"`
 	Contents string `xml:",chardata"`
 }
 // Write creates an XML document and writes it to out.
 func Write(out io.Writer, exec *testjson.Execution) error {
 	return errors.Wrap(write(out, generate(exec)), "failed to write JUnit XML")
 }
 func generate(exec *testjson.Execution) JUnitTestSuites {
 	version := goVersion()
 	suites := JUnitTestSuites{}
 	for _, pkgname := range exec.Packages() {
 		pkg := exec.Package(pkgname)
 		junitpkg := JUnitTestSuite{
 			Name:       pkgname,
 			Tests:      pkg.Total,
 			Time:       formatDurationAsSeconds(pkg.Elapsed()),
 			Properties: packageProperties(version),
 			TestCases:  packageTestCases(pkg),
 			Failures:   len(pkg.Failed),
 		}
 		suites.Suites = append(suites.Suites, junitpkg)
 	}
 	return suites
 }
 func formatDurationAsSeconds(d time.Duration) string {
 	return fmt.Sprintf("%f", d.Seconds())
 }
 func packageProperties(goVersion string) []JUnitProperty {
 	return []JUnitProperty{
 		{Name: "go.version", Value: goVersion},
 	}
 }
 // goVersion returns the version as reported by the go binary in PATH. This
 // version will not be the same as runtime.Version, which is always the version
 // of go used to build the gotestsum binary.
 //
 // To skip the os/exec call set the GOVERSION environment variable to the
 // desired value.
 func goVersion() string {
 	if version, ok := os.LookupEnv("GOVERSION"); ok {
 		return version
 	}
 	logrus.Debugf("exec: go version")
 	cmd := exec.Command("go", "version")
 	out, err := cmd.Output()
 	if err != nil {
 		logrus.WithError(err).Warn("failed to lookup go version for junit xml")
 		return "unknown"
 	}
 	return strings.TrimPrefix(strings.TrimSpace(string(out)), "go version ")
 }
 func packageTestCases(pkg *testjson.Package) []JUnitTestCase {
 	cases := []JUnitTestCase{}
 	if pkg.TestMainFailed() {
 		jtc := newJUnitTestCase(testjson.TestCase{
 			Test: "TestMain",
 		})
 		jtc.Failure = &JUnitFailure{
 			Message:  "Failed",
 			Contents: pkg.Output(""),
 		}
 		cases = append(cases, jtc)
 	}
 	for _, tc := range pkg.Failed {
 		jtc := newJUnitTestCase(tc)
 		jtc.Failure = &JUnitFailure{
 			Message:  "Failed",
 			Contents: pkg.Output(tc.Test),
 		}
 		cases = append(cases, jtc)
 	}
 	for _, tc := range pkg.Skipped {
 		jtc := newJUnitTestCase(tc)
 		jtc.SkipMessage = &JUnitSkipMessage{Message: pkg.Output(tc.Test)}
 		cases = append(cases, jtc)
 	}
 	for _, tc := range pkg.Passed {
 		jtc := newJUnitTestCase(tc)
 		cases = append(cases, jtc)
 	}
 	return cases
 }
 func newJUnitTestCase(tc testjson.TestCase) JUnitTestCase {
 	return JUnitTestCase{
 		Classname: tc.Package,
 		Name:      tc.Test,
 		Time:      formatDurationAsSeconds(tc.Elapsed),
 	}
 }
 func write(out io.Writer, suites JUnitTestSuites) error {
 	doc, err := xml.MarshalIndent(suites, "", "\t")
 	if err != nil {
 		return err
 	}
 	_, err = out.Write([]byte(xml.Header))
 	if err != nil {
 		return err
 	}
 	_, err = out.Write(doc)
 	return err
 }
--- a/vendor/gotest.tools/gotestsum/main.go
+++ b/vendor/gotest.tools/gotestsum/main.go
@ -0,0 +1,214 @@
 package main
 import (
 	"context"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
 	"strings"
 	"github.com/fatih/color"
 	"github.com/pkg/errors"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/pflag"
 	"gotest.tools/gotestsum/testjson"
 )
 var version = "master"
 func main() {
 	name := os.Args[0]
 	flags, opts := setupFlags(name)
 	switch err := flags.Parse(os.Args[1:]); {
 	case err == pflag.ErrHelp:
 		os.Exit(0)
 	case err != nil:
 		log.Error(err.Error())
 		flags.Usage()
 		os.Exit(1)
 	}
 	opts.args = flags.Args()
 	setupLogging(opts)
 	if opts.version {
 		fmt.Fprintf(os.Stdout, "gotestsum version %s\n", version)
 		os.Exit(0)
 	}
 	switch err := run(opts).(type) {
 	case nil:
 	case *exec.ExitError:
 		// go test should already report the error to stderr so just exit with
 		// the same status code
 		os.Exit(ExitCodeWithDefault(err))
 	default:
 		fmt.Fprintln(os.Stderr, name+": Error: "+err.Error())
 		os.Exit(3)
 	}
 }
 func setupFlags(name string) (*pflag.FlagSet, *options) {
 	opts := &options{noSummary: newNoSummaryValue()}
 	flags := pflag.NewFlagSet(name, pflag.ContinueOnError)
 	flags.SetInterspersed(false)
 	flags.Usage = func() {
 		fmt.Fprintf(os.Stderr, `Usage:
    %s [flags] [--] [go test flags]
 Flags:
 `, name)
 		flags.PrintDefaults()
 		fmt.Fprint(os.Stderr, `
 Formats:
    dots              print a character for each test
    short             print a line for each package
    short-verbose     print a line for each test and package
    standard-quiet    default go test format
    standard-verbose  default go test -v format
 `)
 	}
 	flags.BoolVar(&opts.debug, "debug", false, "enabled debug")
 	flags.StringVarP(&opts.format, "format", "f",
 		lookEnvWithDefault("GOTESTSUM_FORMAT", "short"),
 		"print format of test input")
 	flags.BoolVar(&opts.rawCommand, "raw-command", false,
 		"don't prepend 'go test -json' to the 'go test' command")
 	flags.StringVar(&opts.jsonFile, "jsonfile",
 		lookEnvWithDefault("GOTESTSUM_JSONFILE", ""),
 		"write all TestEvents to file")
 	flags.StringVar(&opts.junitFile, "junitfile",
 		lookEnvWithDefault("GOTESTSUM_JUNITFILE", ""),
 		"write a JUnit XML file")
 	flags.BoolVar(&opts.noColor, "no-color", false, "disable color output")
 	flags.Var(opts.noSummary, "no-summary",
 		fmt.Sprintf("do not print summary of: %s", testjson.SummarizeAll.String()))
 	flags.BoolVar(&opts.version, "version", false, "show version and exit")
 	return flags, opts
 }
 func lookEnvWithDefault(key, defValue string) string {
 	if value := os.Getenv(key); value != "" {
 		return value
 	}
 	return defValue
 }
 type options struct {
 	args       []string
 	format     string
 	debug      bool
 	rawCommand bool
 	jsonFile   string
 	junitFile  string
 	noColor    bool
 	noSummary  *noSummaryValue
 	version    bool
 }
 func setupLogging(opts *options) {
 	if opts.debug {
 		log.SetLevel(log.DebugLevel)
 	}
 	if opts.noColor {
 		color.NoColor = true
 	}
 }
 // TODO: add flag --max-failures
 func run(opts *options) error {
 	ctx := context.Background()
 	goTestProc, err := startGoTest(ctx, goTestCmdArgs(opts))
 	if err != nil {
 		return errors.Wrapf(err, "failed to run %s %s",
 			goTestProc.cmd.Path,
 			strings.Join(goTestProc.cmd.Args, " "))
 	}
 	defer goTestProc.cancel()
 	out := os.Stdout
 	handler, err := newEventHandler(opts, out, os.Stderr)
 	if err != nil {
 		return err
 	}
 	defer handler.Close() // nolint: errcheck
 	exec, err := testjson.ScanTestOutput(testjson.ScanConfig{
 		Stdout:  goTestProc.stdout,
 		Stderr:  goTestProc.stderr,
 		Handler: handler,
 	})
 	if err != nil {
 		return err
 	}
 	if err := testjson.PrintSummary(out, exec, opts.noSummary.value); err != nil {
 		return err
 	}
 	if err := writeJUnitFile(opts.junitFile, exec); err != nil {
 		return err
 	}
 	return goTestProc.cmd.Wait()
 }
 func goTestCmdArgs(opts *options) []string {
 	args := opts.args
 	defaultArgs := []string{"go", "test"}
 	switch {
 	case opts.rawCommand:
 		return args
 	case len(args) == 0:
 		return append(defaultArgs, "-json", pathFromEnv("./..."))
 	case !hasJSONArg(args):
 		defaultArgs = append(defaultArgs, "-json")
 	}
 	if testPath := pathFromEnv(""); testPath != "" {
 		args = append(args, testPath)
 	}
 	return append(defaultArgs, args...)
 }
 func pathFromEnv(defaultPath string) string {
 	return lookEnvWithDefault("TEST_DIRECTORY", defaultPath)
 }
 func hasJSONArg(args []string) bool {
 	for _, arg := range args {
 		if arg == "-json" || arg == "--json" {
 			return true
 		}
 	}
 	return false
 }
 type proc struct {
 	cmd    *exec.Cmd
 	stdout io.Reader
 	stderr io.Reader
 	cancel func()
 }
 func startGoTest(ctx context.Context, args []string) (proc, error) {
 	if len(args) == 0 {
 		return proc{}, errors.New("missing command to run")
 	}
 	ctx, cancel := context.WithCancel(ctx)
 	p := proc{
 		cmd:    exec.CommandContext(ctx, args[0], args[1:]...),
 		cancel: cancel,
 	}
 	log.Debugf("exec: %s", p.cmd.Args)
 	var err error
 	p.stdout, err = p.cmd.StdoutPipe()
 	if err != nil {
 		return p, err
 	}
 	p.stderr, err = p.cmd.StderrPipe()
 	if err != nil {
 		return p, err
 	}
 	err = p.cmd.Start()
 	if err == nil {
 		log.Debugf("go test pid: %d", p.cmd.Process.Pid)
 	}
 	return p, err
 }
--- a/vendor/gotest.tools/gotestsum/testjson/BUILD
+++ b/vendor/gotest.tools/gotestsum/testjson/BUILD
@ -0,0 +1,36 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_library")
 go_library(
    name = "go_default_library",
    srcs = [
        "doc.go",
        "execution.go",
        "format.go",
        "pkgpathprefix.go",
        "summary.go",
    ],
    importmap = "k8s.io/kubernetes/vendor/gotest.tools/gotestsum/testjson",
    importpath = "gotest.tools/gotestsum/testjson",
    visibility = ["//visibility:public"],
    deps = [
        "//vendor/github.com/fatih/color:go_default_library",
        "//vendor/github.com/jonboulle/clockwork:go_default_library",
        "//vendor/github.com/pkg/errors:go_default_library",
        "//vendor/github.com/sirupsen/logrus:go_default_library",
        "//vendor/golang.org/x/sync/errgroup:go_default_library",
    ],
 )
 filegroup(
    name = "package-srcs",
    srcs = glob(["**"]),
    tags = ["automanaged"],
    visibility = ["//visibility:private"],
 )
 filegroup(
    name = "all-srcs",
    srcs = [":package-srcs"],
    tags = ["automanaged"],
    visibility = ["//visibility:public"],
 )
--- a/vendor/gotest.tools/gotestsum/testjson/doc.go
+++ b/vendor/gotest.tools/gotestsum/testjson/doc.go
@ -0,0 +1 @@
 package testjson // import "gotest.tools/gotestsum/testjson"
--- a/vendor/gotest.tools/gotestsum/testjson/execution.go
+++ b/vendor/gotest.tools/gotestsum/testjson/execution.go
@ -0,0 +1,379 @@
 package testjson
 import (
 	"bufio"
 	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
 	"sort"
 	"strings"
 	"time"
 	"github.com/jonboulle/clockwork"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/sync/errgroup"
 )
 // Action of TestEvent
 type Action string
 // nolint: unused
 const (
 	ActionRun    Action = "run"
 	ActionPause  Action = "pause"
 	ActionCont   Action = "cont"
 	ActionPass   Action = "pass"
 	ActionBench  Action = "bench"
 	ActionFail   Action = "fail"
 	ActionOutput Action = "output"
 	ActionSkip   Action = "skip"
 )
 // TestEvent is a structure output by go tool test2json and go test -json.
 type TestEvent struct {
 	// Time encoded as an RFC3339-format string
 	Time    time.Time
 	Action  Action
 	Package string
 	Test    string
 	// Elapsed time in seconds
 	Elapsed float64
 	// Output of test or benchmark
 	Output string
 	// raw is the raw JSON bytes of the event
 	raw []byte
 }
 // PackageEvent returns true if the event is a package start or end event
 func (e TestEvent) PackageEvent() bool {
 	return e.Test == ""
 }
 // ElapsedFormatted returns Elapsed formatted in the go test format, ex (0.00s).
 func (e TestEvent) ElapsedFormatted() string {
 	return fmt.Sprintf("(%.2fs)", e.Elapsed)
 }
 // Bytes returns the serialized JSON bytes that were parsed to create the event.
 func (e TestEvent) Bytes() []byte {
 	return e.raw
 }
 // Package is the set of TestEvents for a single go package
 type Package struct {
 	// TODO: this could be Total()
 	Total   int
 	Failed  []TestCase
 	Skipped []TestCase
 	Passed  []TestCase
 	output  map[string][]string
 	// coverage stores the code coverage output for the package without the
 	// trailing newline (ex: coverage: 91.1% of statements).
 	coverage string
 	// action identifies if the package passed or failed. A package may fail
 	// with no test failures if an init() or TestMain exits non-zero.
 	// skip indicates there were no tests.
 	action Action
 }
 // Result returns if the package passed, failed, or was skipped because there
 // were no tests.
 func (p Package) Result() Action {
 	return p.action
 }
 // Elapsed returns the sum of the elapsed time for all tests in the package.
 func (p Package) Elapsed() time.Duration {
 	elapsed := time.Duration(0)
 	for _, testcase := range p.TestCases() {
 		elapsed += testcase.Elapsed
 	}
 	return elapsed
 }
 // TestCases returns all the test cases.
 func (p Package) TestCases() []TestCase {
 	return append(append(p.Passed, p.Failed...), p.Skipped...)
 }
 // Output returns the full test output for a test.
 func (p Package) Output(test string) string {
 	return strings.Join(p.output[test], "")
 }
 // TestMainFailed returns true if the package failed, but there were no tests.
 // This may occur if the package init() or TestMain exited non-zero.
 func (p Package) TestMainFailed() bool {
 	return p.action == ActionFail && len(p.Failed) == 0
 }
 // TestCase stores the name and elapsed time for a test case.
 type TestCase struct {
 	Package string
 	Test    string
 	Elapsed time.Duration
 }
 func newPackage() *Package {
 	return &Package{output: make(map[string][]string)}
 }
 // Execution of one or more test packages
 type Execution struct {
 	started  time.Time
 	packages map[string]*Package
 	errors   []string
 }
 func (e *Execution) add(event TestEvent) {
 	pkg, ok := e.packages[event.Package]
 	if !ok {
 		pkg = newPackage()
 		e.packages[event.Package] = pkg
 	}
 	if event.PackageEvent() {
 		e.addPackageEvent(pkg, event)
 		return
 	}
 	e.addTestEvent(pkg, event)
 }
 func (e *Execution) addPackageEvent(pkg *Package, event TestEvent) {
 	switch event.Action {
 	case ActionPass, ActionFail:
 		pkg.action = event.Action
 	case ActionOutput:
 		if isCoverageOutput(event.Output) {
 			pkg.coverage = strings.TrimRight(event.Output, "\n")
 		}
 		pkg.output[""] = append(pkg.output[""], event.Output)
 	}
 }
 func (e *Execution) addTestEvent(pkg *Package, event TestEvent) {
 	switch event.Action {
 	case ActionRun:
 		pkg.Total++
 	case ActionFail:
 		pkg.Failed = append(pkg.Failed, TestCase{
 			Package: event.Package,
 			Test:    event.Test,
 			Elapsed: elapsedDuration(event.Elapsed),
 		})
 	case ActionSkip:
 		pkg.Skipped = append(pkg.Skipped, TestCase{
 			Package: event.Package,
 			Test:    event.Test,
 			Elapsed: elapsedDuration(event.Elapsed),
 		})
 	case ActionOutput, ActionBench:
 		// TODO: limit size of buffered test output
 		pkg.output[event.Test] = append(pkg.output[event.Test], event.Output)
 	case ActionPass:
 		pkg.Passed = append(pkg.Passed, TestCase{
 			Package: event.Package,
 			Test:    event.Test,
 			Elapsed: elapsedDuration(event.Elapsed),
 		})
 		// Remove test output once a test passes, it wont be used
 		delete(pkg.output, event.Test)
 	}
 }
 func elapsedDuration(elapsed float64) time.Duration {
 	return time.Duration(elapsed*1000) * time.Millisecond
 }
 func isCoverageOutput(output string) bool {
 	return all(
 		strings.HasPrefix(output, "coverage:"),
 		strings.HasSuffix(output, "% of statements\n"))
 }
 // Output returns the full test output for a test.
 func (e *Execution) Output(pkg, test string) string {
 	return strings.Join(e.packages[pkg].output[test], "")
 }
 // OutputLines returns the full test output for a test as an array of lines.
 func (e *Execution) OutputLines(pkg, test string) []string {
 	return e.packages[pkg].output[test]
 }
 // Package returns the Package by name.
 func (e *Execution) Package(name string) *Package {
 	return e.packages[name]
 }
 // Packages returns a sorted list of all package names.
 func (e *Execution) Packages() []string {
 	return sortedKeys(e.packages)
 }
 var clock = clockwork.NewRealClock()
 // Elapsed returns the time elapsed since the execution started.
 func (e *Execution) Elapsed() time.Duration {
 	return clock.Now().Sub(e.started)
 }
 // Failed returns a list of all the failed test cases.
 func (e *Execution) Failed() []TestCase {
 	var failed []TestCase
 	for _, name := range sortedKeys(e.packages) {
 		pkg := e.packages[name]
 		// Add package-level failure output if there were no failed tests.
 		if pkg.TestMainFailed() {
 			failed = append(failed, TestCase{Package: name})
 		} else {
 			failed = append(failed, pkg.Failed...)
 		}
 	}
 	return failed
 }
 func sortedKeys(pkgs map[string]*Package) []string {
 	keys := make([]string, 0, len(pkgs))
 	for key := range pkgs {
 		keys = append(keys, key)
 	}
 	sort.Strings(keys)
 	return keys
 }
 // Skipped returns a list of all the skipped test cases.
 func (e *Execution) Skipped() []TestCase {
 	skipped := make([]TestCase, 0, len(e.packages))
 	for _, pkg := range sortedKeys(e.packages) {
 		skipped = append(skipped, e.packages[pkg].Skipped...)
 	}
 	return skipped
 }
 // Total returns a count of all test cases.
 func (e *Execution) Total() int {
 	total := 0
 	for _, pkg := range e.packages {
 		total += pkg.Total
 	}
 	return total
 }
 func (e *Execution) addError(err string) {
 	// Build errors start with a header
 	if strings.HasPrefix(err, "# ") {
 		return
 	}
 	// TODO: may need locking, or use a channel
 	e.errors = append(e.errors, err)
 }
 // Errors returns a list of all the errors.
 func (e *Execution) Errors() []string {
 	return e.errors
 }
 // NewExecution returns a new Execution and records the current time as the
 // time the test execution started.
 func NewExecution() *Execution {
 	return &Execution{
 		started:  time.Now(),
 		packages: make(map[string]*Package),
 	}
 }
 // ScanConfig used by ScanTestOutput
 type ScanConfig struct {
 	Stdout  io.Reader
 	Stderr  io.Reader
 	Handler EventHandler
 }
 // EventHandler is called by ScanTestOutput for each event and write to stderr.
 type EventHandler interface {
 	Event(event TestEvent, execution *Execution) error
 	Err(text string) error
 }
 // ScanTestOutput reads lines from stdout and stderr, creates an Execution,
 // calls the Handler for each event, and returns the Execution.
 func ScanTestOutput(config ScanConfig) (*Execution, error) {
 	execution := NewExecution()
 	var group errgroup.Group
 	group.Go(func() error {
 		return readStdout(config, execution)
 	})
 	group.Go(func() error {
 		return readStderr(config, execution)
 	})
 	return execution, group.Wait()
 }
 func readStdout(config ScanConfig, execution *Execution) error {
 	scanner := bufio.NewScanner(config.Stdout)
 	for scanner.Scan() {
 		raw := scanner.Bytes()
 		event, err := parseEvent(raw)
 		switch {
 		case err == errBadEvent:
 			// nolint: errcheck
 			config.Handler.Err(errBadEvent.Error() + ": " + scanner.Text())
 			continue
 		case err != nil:
 			return errors.Wrapf(err, "failed to parse test output: %s", string(raw))
 		}
 		execution.add(event)
 		if err := config.Handler.Event(event, execution); err != nil {
 			return err
 		}
 	}
 	return errors.Wrap(scanner.Err(), "failed to scan test output")
 }
 func readStderr(config ScanConfig, execution *Execution) error {
 	scanner := bufio.NewScanner(config.Stderr)
 	for scanner.Scan() {
 		line := scanner.Text()
 		config.Handler.Err(line) // nolint: errcheck
 		if isGoModuleOutput(line) {
 			continue
 		}
 		execution.addError(line)
 	}
 	return errors.Wrap(scanner.Err(), "failed to scan test stderr")
 }
 func isGoModuleOutput(scannerText string) bool {
 	prefixes := []string{
 		"go: copying",
 		"go: creating",
 		"go: downloading",
 		"go: extracting",
 		"go: finding",
 	}
 	for _, prefix := range prefixes {
 		if strings.HasPrefix(scannerText, prefix) {
 			return true
 		}
 	}
 	return false
 }
 func parseEvent(raw []byte) (TestEvent, error) {
 	// TODO: this seems to be a bug in the `go test -json` output
 	if bytes.HasPrefix(raw, []byte("FAIL")) {
 		logrus.Warn(string(raw))
 		return TestEvent{}, errBadEvent
 	}
 	event := TestEvent{}
 	err := json.Unmarshal(raw, &event)
 	event.raw = raw
 	return event, err
 }
 var errBadEvent = errors.New("bad output from test2json")
--- a/vendor/gotest.tools/gotestsum/testjson/format.go
+++ b/vendor/gotest.tools/gotestsum/testjson/format.go
@ -0,0 +1,189 @@
 package testjson
 import (
 	"fmt"
 	"strings"
 	"github.com/fatih/color"
 )
 // EventFormatter is a function which handles an event and returns a string to
 // output for the event.
 type EventFormatter func(event TestEvent, output *Execution) (string, error)
 func debugFormat(event TestEvent, _ *Execution) (string, error) {
 	return fmt.Sprintf("%s %s %s (%.3f) [%d] %s\n",
 		event.Package,
 		event.Test,
 		event.Action,
 		event.Elapsed,
 		event.Time.Unix(),
 		event.Output), nil
 }
 // go test -v
 func standardVerboseFormat(event TestEvent, _ *Execution) (string, error) {
 	if event.Action == ActionOutput {
 		return event.Output, nil
 	}
 	return "", nil
 }
 // go test
 func standardQuietFormat(event TestEvent, _ *Execution) (string, error) {
 	if !event.PackageEvent() {
 		return "", nil
 	}
 	if event.Output != "PASS\n" && !isCoverageOutput(event.Output) {
 		return event.Output, nil
 	}
 	return "", nil
 }
 func shortVerboseFormat(event TestEvent, exec *Execution) (string, error) {
 	result := colorEvent(event)(strings.ToUpper(string(event.Action)))
 	formatTest := func() string {
 		return fmt.Sprintf("%s %s.%s %s\n",
 			result,
 			relativePackagePath(event.Package),
 			event.Test,
 			event.ElapsedFormatted())
 	}
 	switch {
 	case isPkgFailureOutput(event):
 		return event.Output, nil
 	case event.PackageEvent():
 		switch event.Action {
 		case ActionSkip:
 			result = colorEvent(event)("EMPTY")
 			fallthrough
 		case ActionPass, ActionFail:
 			return fmt.Sprintf("%s %s\n", result, relativePackagePath(event.Package)), nil
 		}
 	case event.Action == ActionFail:
 		return exec.Output(event.Package, event.Test) + formatTest(), nil
 	case event.Action == ActionPass:
 		return formatTest(), nil
 	}
 	return "", nil
 }
 // isPkgFailureOutput returns true if the event is package output, and the output
 // doesn't match any of the expected framing messages. Events which match this
 // pattern should be package-level failures (ex: exit(1) or panic in an init() or
 // TestMain).
 func isPkgFailureOutput(event TestEvent) bool {
 	out := event.Output
 	return all(
 		event.PackageEvent(),
 		event.Action == ActionOutput,
 		out != "PASS\n",
 		out != "FAIL\n",
 		!strings.HasPrefix(out, "FAIL\t"+event.Package),
 		!strings.HasPrefix(out, "ok  \t"+event.Package),
 		!strings.HasPrefix(out, "?   \t"+event.Package),
 	)
 }
 func all(cond ...bool) bool {
 	for _, c := range cond {
 		if !c {
 			return false
 		}
 	}
 	return true
 }
 func shortFormat(event TestEvent, exec *Execution) (string, error) {
 	if !event.PackageEvent() {
 		return "", nil
 	}
 	fmtElapsed := func() string {
 		d := elapsedDuration(event.Elapsed)
 		if d == 0 {
 			return ""
 		}
 		return fmt.Sprintf(" (%s)", d)
 	}
 	fmtCoverage := func() string {
 		pkg := exec.Package(event.Package)
 		if pkg.coverage == "" {
 			return ""
 		}
 		return "     (" + pkg.coverage + ")"
 	}
 	fmtEvent := func(action string) (string, error) {
 		return fmt.Sprintf("%s  %s%s%s\n",
 			action,
 			relativePackagePath(event.Package),
 			fmtElapsed(),
 			fmtCoverage(),
 		), nil
 	}
 	withColor := colorEvent(event)
 	switch event.Action {
 	case ActionSkip:
 		return fmtEvent(withColor("∅"))
 	case ActionPass:
 		return fmtEvent(withColor("✓"))
 	case ActionFail:
 		return fmtEvent(withColor("✖"))
 	}
 	return "", nil
 }
 func dotsFormat(event TestEvent, exec *Execution) (string, error) {
 	pkg := exec.Package(event.Package)
 	withColor := colorEvent(event)
 	switch {
 	case event.PackageEvent():
 		return "", nil
 	case event.Action == ActionRun && pkg.Total == 1:
 		return "[" + relativePackagePath(event.Package) + "]", nil
 	case event.Action == ActionPass:
 		return withColor("·"), nil
 	case event.Action == ActionFail:
 		return withColor("✖"), nil
 	case event.Action == ActionSkip:
 		return withColor("↷"), nil
 	}
 	return "", nil
 }
 func colorEvent(event TestEvent) func(format string, a ...interface{}) string {
 	switch event.Action {
 	case ActionPass:
 		return color.GreenString
 	case ActionFail:
 		return color.RedString
 	case ActionSkip:
 		return color.YellowString
 	}
 	return color.WhiteString
 }
 // NewEventFormatter returns a formatter for printing events.
 func NewEventFormatter(format string) EventFormatter {
 	switch format {
 	case "debug":
 		return debugFormat
 	case "standard-verbose":
 		return standardVerboseFormat
 	case "standard-quiet":
 		return standardQuietFormat
 	case "dots":
 		return dotsFormat
 	case "short-verbose":
 		return shortVerboseFormat
 	case "short":
 		return shortFormat
 	default:
 		return nil
 	}
 }
--- a/vendor/gotest.tools/gotestsum/testjson/generate.sh
+++ b/vendor/gotest.tools/gotestsum/testjson/generate.sh
@ -0,0 +1,34 @@
 #!/usr/bin/env bash
 set -eu
 go test -p 1 -tags stubpkg ./internal/... \
    > testdata/go-test-quiet.out \
    2> testdata/go-test-quiet.err \
    | true
 go test -p 1 -v -tags stubpkg ./internal/... \
    > testdata/go-test-verbose.out \
    2> testdata/go-test-verbose.err \
    | true
 go test -p 1 -json -tags stubpkg ./internal/... \
    > testdata/go-test-json.out \
    2> testdata/go-test-json.err \
    | true
 go test -p 1 -json -timeout 10ms -tags 'stubpkg timeout' ./internal/... \
    > testdata/go-test-json-with-timeout.out \
    2> testdata/go-test-json-with-timeout.err \
    | true
 go test -p 1 -json -tags 'stubpkg panic' ./internal/... \
    > testdata/go-test-json-with-panic.out \
    2> testdata/go-test-json-with-panic.err \
    | true
 go test -p 1 -json -tags stubpkg -cover ./internal/... \
    > testdata/go-test-json-with-cover.out \
    2> testdata/go-test-json-with-cover.err \
    | true
--- a/vendor/gotest.tools/gotestsum/testjson/pkgpathprefix.go
+++ b/vendor/gotest.tools/gotestsum/testjson/pkgpathprefix.go
@ -0,0 +1,126 @@
 package testjson
 import (
 	"bytes"
 	"go/build"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strconv"
 	"strings"
 )
 func relativePackagePath(pkgpath string) string {
 	if pkgpath == pkgPathPrefix {
 		return "."
 	}
 	return strings.TrimPrefix(pkgpath, pkgPathPrefix+"/")
 }
 func getPkgPathPrefix() string {
 	cwd, _ := os.Getwd()
 	if isGoModuleEnabled() {
 		prefix := getPkgPathPrefixFromGoModule(cwd)
 		if prefix != "" {
 			return prefix
 		}
 	}
 	return getPkgPathPrefixGoPath(cwd)
 }
 func isGoModuleEnabled() bool {
 	version := runtime.Version()
 	if strings.HasPrefix(version, "go1.10") {
 		return false
 	}
 	// Go modules may not be enabled if env var is unset, or set to auto, however
 	// we can always fall back to using GOPATH as the prefix if a go.mod is not
 	// found.
 	return os.Getenv("GO111MODULE") != "off"
 }
 // TODO: might not work on windows
 func getPkgPathPrefixGoPath(cwd string) string {
 	gopaths := strings.Split(build.Default.GOPATH, string(filepath.ListSeparator))
 	for _, gopath := range gopaths {
 		gosrcpath := gopath + "/src/"
 		if strings.HasPrefix(cwd, gosrcpath) {
 			return strings.TrimPrefix(cwd, gosrcpath)
 		}
 	}
 	return ""
 }
 func getPkgPathPrefixFromGoModule(cwd string) string {
 	filename := goModuleFilePath(cwd)
 	if filename == "" {
 		return ""
 	}
 	raw, err := ioutil.ReadFile(filename)
 	if err != nil {
 		// TODO: log.Warn
 		return ""
 	}
 	return pkgPathFromGoModuleFile(raw)
 }
 var (
 	slashSlash = []byte("//")
 	moduleStr  = []byte("module")
 )
 // Copy of ModulePath from golang.org/src/cmd/go/internal/modfile/read.go
 func pkgPathFromGoModuleFile(mod []byte) string {
 	for len(mod) > 0 {
 		line := mod
 		mod = nil
 		if i := bytes.IndexByte(line, '\n'); i >= 0 {
 			line, mod = line[:i], line[i+1:]
 		}
 		if i := bytes.Index(line, slashSlash); i >= 0 {
 			line = line[:i]
 		}
 		line = bytes.TrimSpace(line)
 		if !bytes.HasPrefix(line, moduleStr) {
 			continue
 		}
 		line = line[len(moduleStr):]
 		n := len(line)
 		line = bytes.TrimSpace(line)
 		if len(line) == n || len(line) == 0 {
 			continue
 		}
 		if line[0] == '"' || line[0] == '`' {
 			p, err := strconv.Unquote(string(line))
 			if err != nil {
 				return "" // malformed quoted string or multi-line module path
 			}
 			return p
 		}
 		return string(line)
 	}
 	return "" // missing module path
 }
 // A rough re-implementation of FindModuleRoot from
 // golang.org/src/cmd/go/internal/modload/init.go
 func goModuleFilePath(cwd string) string {
 	dir := filepath.Clean(cwd)
 	for {
 		path := filepath.Join(dir, "go.mod")
 		if _, err := os.Stat(path); err == nil {
 			return path
 		}
 		parent := filepath.Dir(dir)
 		if parent == dir {
 			return ""
 		}
 		dir = parent
 	}
 }
 var pkgPathPrefix = getPkgPathPrefix()
--- a/vendor/gotest.tools/gotestsum/testjson/summary.go
+++ b/vendor/gotest.tools/gotestsum/testjson/summary.go
@ -0,0 +1,214 @@
 package testjson
 import (
 	"fmt"
 	"io"
 	"strings"
 	"time"
 	"unicode"
 	"unicode/utf8"
 	"github.com/fatih/color"
 )
 // Summary enumerates the sections which can be printed by PrintSummary
 type Summary int
 // nolint: golint
 const (
 	SummarizeNone    Summary = 0
 	SummarizeSkipped Summary = (1 << iota) / 2
 	SummarizeFailed
 	SummarizeErrors
 	SummarizeOutput
 	SummarizeAll = SummarizeSkipped | SummarizeFailed | SummarizeErrors | SummarizeOutput
 )
 var summaryValues = map[Summary]string{
 	SummarizeSkipped: "skipped",
 	SummarizeFailed:  "failed",
 	SummarizeErrors:  "errors",
 	SummarizeOutput:  "output",
 }
 var summaryFromValue = map[string]Summary{
 	"none":    SummarizeNone,
 	"skipped": SummarizeSkipped,
 	"failed":  SummarizeFailed,
 	"errors":  SummarizeErrors,
 	"output":  SummarizeOutput,
 	"all":     SummarizeAll,
 }
 func (s Summary) String() string {
 	if s == SummarizeNone {
 		return "none"
 	}
 	var result []string
 	for v := Summary(1); v <= s; v <<= 1 {
 		if s.Includes(v) {
 			result = append(result, summaryValues[v])
 		}
 	}
 	return strings.Join(result, ",")
 }
 // Includes returns true if Summary includes all the values set by other.
 func (s Summary) Includes(other Summary) bool {
 	return s&other == other
 }
 // NewSummary returns a new Summary from a string value. If the string does not
 // match any known values returns false for the second value.
 func NewSummary(value string) (Summary, bool) {
 	s, ok := summaryFromValue[value]
 	return s, ok
 }
 // PrintSummary of a test Execution. Prints a section for each summary type
 // followed by a DONE line.
 func PrintSummary(out io.Writer, execution *Execution, opts Summary) error {
 	execSummary := newExecSummary(execution, opts)
 	if opts.Includes(SummarizeSkipped) {
 		writeTestCaseSummary(out, execSummary, formatSkipped())
 	}
 	if opts.Includes(SummarizeFailed) {
 		writeTestCaseSummary(out, execSummary, formatFailed())
 	}
 	errors := execution.Errors()
 	if opts.Includes(SummarizeErrors) {
 		writeErrorSummary(out, errors)
 	}
 	fmt.Fprintf(out, "\n%s %d tests%s%s%s in %s\n",
 		"DONE", // TODO: maybe color this?
 		execution.Total(),
 		formatTestCount(len(execution.Skipped()), "skipped", ""),
 		formatTestCount(len(execution.Failed()), "failure", "s"),
 		formatTestCount(countErrors(errors), "error", "s"),
 		FormatDurationAsSeconds(execution.Elapsed(), 3))
 	return nil
 }
 func formatTestCount(count int, category string, pluralize string) string {
 	switch count {
 	case 0:
 		return ""
 	case 1:
 	default:
 		category += pluralize
 	}
 	return fmt.Sprintf(", %d %s", count, category)
 }
 // FormatDurationAsSeconds formats a time.Duration as a float with an s suffix.
 func FormatDurationAsSeconds(d time.Duration, precision int) string {
 	return fmt.Sprintf("%.[2]*[1]fs", d.Seconds(), precision)
 }
 func writeErrorSummary(out io.Writer, errors []string) {
 	if len(errors) > 0 {
 		fmt.Fprintln(out, color.MagentaString("\n=== Errors"))
 	}
 	for _, err := range errors {
 		fmt.Fprintln(out, err)
 	}
 }
 // countErrors in stderr lines. Build errors may include multiple lines where
 // subsequent lines are indented.
 // FIXME: Panics will include multiple lines, and are still overcounted.
 func countErrors(errors []string) int {
 	var count int
 	for _, line := range errors {
 		r, _ := utf8.DecodeRuneInString(line)
 		if !unicode.IsSpace(r) {
 			count++
 		}
 	}
 	return count
 }
 type executionSummary interface {
 	Failed() []TestCase
 	Skipped() []TestCase
 	OutputLines(pkg, test string) []string
 }
 type noOutputSummary struct {
 	Execution
 }
 func (s *noOutputSummary) OutputLines(_, _ string) []string {
 	return nil
 }
 func newExecSummary(execution *Execution, opts Summary) executionSummary {
 	if opts.Includes(SummarizeOutput) {
 		return execution
 	}
 	return &noOutputSummary{Execution: *execution}
 }
 func writeTestCaseSummary(out io.Writer, execution executionSummary, conf testCaseFormatConfig) {
 	testCases := conf.getter(execution)
 	if len(testCases) == 0 {
 		return
 	}
 	fmt.Fprintln(out, "\n=== "+conf.header)
 	for _, tc := range testCases {
 		fmt.Fprintf(out, "=== %s: %s %s (%s)\n",
 			conf.prefix,
 			relativePackagePath(tc.Package),
 			tc.Test,
 			FormatDurationAsSeconds(tc.Elapsed, 2))
 		for _, line := range execution.OutputLines(tc.Package, tc.Test) {
 			if isRunLine(line) || conf.filter(line) {
 				continue
 			}
 			fmt.Fprint(out, line)
 		}
 		fmt.Fprintln(out)
 	}
 }
 type testCaseFormatConfig struct {
 	header string
 	prefix string
 	filter func(string) bool
 	getter func(executionSummary) []TestCase
 }
 func formatFailed() testCaseFormatConfig {
 	withColor := color.RedString
 	return testCaseFormatConfig{
 		header: withColor("Failed"),
 		prefix: withColor("FAIL"),
 		filter: func(line string) bool {
 			return strings.HasPrefix(line, "--- FAIL: Test")
 		},
 		getter: func(execution executionSummary) []TestCase {
 			return execution.Failed()
 		},
 	}
 }
 func formatSkipped() testCaseFormatConfig {
 	withColor := color.YellowString
 	return testCaseFormatConfig{
 		header: withColor("Skipped"),
 		prefix: withColor("SKIP"),
 		filter: func(line string) bool {
 			return strings.HasPrefix(line, "--- SKIP: Test")
 		},
 		getter: func(execution executionSummary) []TestCase {
 			return execution.Skipped()
 		},
 	}
 }
 func isRunLine(line string) bool {
 	return strings.HasPrefix(line, "=== RUN   Test")
 }
--- a/vendor/gotest.tools/pkg.go
+++ b/vendor/gotest.tools/pkg.go
@ -0,0 +1,4 @@
 /*Package gotesttools is a collection of packages to augment `testing` and
 support common patterns.
 */
 package gotesttools // import "gotest.tools"
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@ -339,6 +339,8 @@ github.com/evanphx/json-patch
 github.com/exponent-io/jsonpath
 # github.com/fatih/camelcase v1.0.0 => github.com/fatih/camelcase v1.0.0
 github.com/fatih/camelcase
 # github.com/fatih/color v1.6.0 => github.com/fatih/color v1.6.0
 github.com/fatih/color
 # github.com/fsnotify/fsnotify v1.4.7 => github.com/fsnotify/fsnotify v1.4.7
 github.com/fsnotify/fsnotify
 # github.com/ghodss/yaml v0.0.0-20180820084758-c7ce16629ff4 => github.com/ghodss/yaml v0.0.0-20180820084758-c7ce16629ff4
@ -562,10 +564,6 @@ github.com/jmespath/go-jmespath
 github.com/jonboulle/clockwork
 # github.com/json-iterator/go v1.1.6 => github.com/json-iterator/go v1.1.6
 github.com/json-iterator/go
 # github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024 => github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024
 github.com/jstemmer/go-junit-report
 github.com/jstemmer/go-junit-report/formatter
 github.com/jstemmer/go-junit-report/parser
 # github.com/karrick/godirwalk v1.7.5 => github.com/karrick/godirwalk v1.7.5
 github.com/karrick/godirwalk
 # github.com/konsorten/go-windows-terminal-sequences v1.0.1 => github.com/konsorten/go-windows-terminal-sequences v1.0.1
@ -590,6 +588,10 @@ github.com/mailru/easyjson/jlexer
 github.com/mailru/easyjson/jwriter
 # github.com/marstr/guid v0.0.0-20170427235115-8bdf7d1a087c => github.com/marstr/guid v0.0.0-20170427235115-8bdf7d1a087c
 github.com/marstr/guid
 # github.com/mattn/go-colorable v0.0.9 => github.com/mattn/go-colorable v0.0.9
 github.com/mattn/go-colorable
 # github.com/mattn/go-isatty v0.0.3 => github.com/mattn/go-isatty v0.0.3
 github.com/mattn/go-isatty
 # github.com/mattn/go-shellwords v1.0.5 => github.com/mattn/go-shellwords v1.0.5
 github.com/mattn/go-shellwords
 # github.com/matttproud/golang_protobuf_extensions v1.0.1 => github.com/matttproud/golang_protobuf_extensions v1.0.1
@ -864,6 +866,8 @@ golang.org/x/oauth2/google
 golang.org/x/oauth2/internal
 golang.org/x/oauth2/jws
 golang.org/x/oauth2/jwt
 # golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 => golang.org/x/sync v0.0.0-20181108010431-42b317875d0f
 golang.org/x/sync/errgroup
 # golang.org/x/sys v0.0.0-20190616124812-15dcb6c0061f => golang.org/x/sys v0.0.0-20190209173611-3b5209105503
 golang.org/x/sys/unix
 golang.org/x/sys/windows
@ -1018,6 +1022,12 @@ gopkg.in/tomb.v1
 gopkg.in/warnings.v0
 # gopkg.in/yaml.v2 v2.2.2 => gopkg.in/yaml.v2 v2.2.2
 gopkg.in/yaml.v2
 # gotest.tools v2.2.0+incompatible => gotest.tools v2.2.0+incompatible
 gotest.tools
 # gotest.tools/gotestsum v0.3.5 => gotest.tools/gotestsum v0.3.5
 gotest.tools/gotestsum
 gotest.tools/gotestsum/internal/junitxml
 gotest.tools/gotestsum/testjson
 # k8s.io/api v0.0.0 => ./staging/src/k8s.io/api
 k8s.io/api/admission/v1beta1
 k8s.io/api/admissionregistration/v1
		`@ -0,0 +1,2 @@`
							`// Package isatty implements interface to isatty`
							`package isatty`
		`@ -0,0 +1 @@`
							`package testjson // import "gotest.tools/gotestsum/testjson"`