From marc at petit-huguenin.org Sat Jun 1 10:29:34 2013 From: marc at petit-huguenin.org (Marc Petit-Huguenin) Date: Sat, 01 Jun 2013 10:29:34 -0700 Subject: lambda expression not expected here Message-ID: <51AA2F7E.7040206@petit-huguenin.org> -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 Hi, The compilation of this code fails with a "lambda expression not expected here" error: int i = (f -> f + 1).applyAsInt(1); I am not sure to understand why this code is invalid as the following code compiles fine: int i = ((IntUnaryOperator)(f -> f + 1)).applyAsInt(1); If it is because the compiler cannot infer the type, then perhaps the error text could be improved. Thanks. - -- Marc Petit-Huguenin Email: marc at petit-huguenin.org Blog: http://blog.marc.petit-huguenin.org Profile: http://www.linkedin.com/in/petithug -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIcBAEBCAAGBQJRqi97AAoJECnERZXWan7E+CsP/14IlYCyFkJsHuP8M1KAp38c ZGiCqyU2zkKGFdZuMNeslUD25NoLjLpBfNRlk1d4kWZzo+zFWKEnnE/wVJB49zRE bG4W9iS0ToktODLfDqawPHb4OAEurrqosA3BzUrAy/C7KoOISvvZwVIbXRO/zQi5 I7/s3G5rb3aN84J6tYjVt0zIKhtBls45slpP+mN9gA8y/u+EZwtQgZc1WhAnKv73 g5iBCvQK68m9bgj/sCs0W/Y60bRD6vpF3QR26z6mFFfT2Q7ykmSbIb0bF2GteFbr coRYM/Y6FtmAayPduSbTS3gDS9GuiHnnvJzwuM9Wgd/f/FkbDnhR8wXNdEoXh+ry klRteAHDzXgOrqHqOfDvWx9JgYqNi7bVw45H8AbsmJj20cdq0Amy8JWEh3iTD6Zy o6aR0iUpDeQ7Kg+IIn0lzccqBnh6+FKqZqsn5mIpNvPULeHTyu2B54AOUi52Kpez xDTiioUaRXLZynWpG2AghWTJqc2uZM7T81O+pPSZLPSaHVC7Dde+IU4KG+PvbuHx 84Rsl7h9wh4pnoxYFcC4WTCinBoF2KZ7MWqT9bUCQGI99FGUvqF4wN76t9tMytbC YztxzG8q3EHXThxH120dk3HhzyXUj5r4wqmHphH0r9kFN1N8u/Z+lELF4nJa/KCc BU9BWzp6qbKMt0PSJ7Dl =YAKJ -----END PGP SIGNATURE----- From brian.goetz at oracle.com Sat Jun 1 10:56:08 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Sat, 1 Jun 2013 10:56:08 -0700 Subject: lambda expression not expected here In-Reply-To: <51AA2F7E.7040206@petit-huguenin.org> References: <51AA2F7E.7040206@petit-huguenin.org> Message-ID: You've mostly got it. A lambda expression needs a type, since it is compatible with many types. It can get its target type from an assignment context, a method invocation context, a cast context, etc. You are right the error message could be better. On Jun 1, 2013, at 10:29 AM, Marc Petit-Huguenin wrote: > -----BEGIN PGP SIGNED MESSAGE----- > Hash: SHA256 > > Hi, > > The compilation of this code fails with a "lambda expression not expected > here" error: > > int i = (f -> f + 1).applyAsInt(1); > > I am not sure to understand why this code is invalid as the following code > compiles fine: > > int i = ((IntUnaryOperator)(f -> f + 1)).applyAsInt(1); > > If it is because the compiler cannot infer the type, then perhaps the error > text could be improved. > > Thanks. > > - -- > Marc Petit-Huguenin > Email: marc at petit-huguenin.org > Blog: http://blog.marc.petit-huguenin.org > Profile: http://www.linkedin.com/in/petithug > -----BEGIN PGP SIGNATURE----- > Version: GnuPG v1.4.12 (GNU/Linux) > > iQIcBAEBCAAGBQJRqi97AAoJECnERZXWan7E+CsP/14IlYCyFkJsHuP8M1KAp38c > ZGiCqyU2zkKGFdZuMNeslUD25NoLjLpBfNRlk1d4kWZzo+zFWKEnnE/wVJB49zRE > bG4W9iS0ToktODLfDqawPHb4OAEurrqosA3BzUrAy/C7KoOISvvZwVIbXRO/zQi5 > I7/s3G5rb3aN84J6tYjVt0zIKhtBls45slpP+mN9gA8y/u+EZwtQgZc1WhAnKv73 > g5iBCvQK68m9bgj/sCs0W/Y60bRD6vpF3QR26z6mFFfT2Q7ykmSbIb0bF2GteFbr > coRYM/Y6FtmAayPduSbTS3gDS9GuiHnnvJzwuM9Wgd/f/FkbDnhR8wXNdEoXh+ry > klRteAHDzXgOrqHqOfDvWx9JgYqNi7bVw45H8AbsmJj20cdq0Amy8JWEh3iTD6Zy > o6aR0iUpDeQ7Kg+IIn0lzccqBnh6+FKqZqsn5mIpNvPULeHTyu2B54AOUi52Kpez > xDTiioUaRXLZynWpG2AghWTJqc2uZM7T81O+pPSZLPSaHVC7Dde+IU4KG+PvbuHx > 84Rsl7h9wh4pnoxYFcC4WTCinBoF2KZ7MWqT9bUCQGI99FGUvqF4wN76t9tMytbC > YztxzG8q3EHXThxH120dk3HhzyXUj5r4wqmHphH0r9kFN1N8u/Z+lELF4nJa/KCc > BU9BWzp6qbKMt0PSJ7Dl > =YAKJ > -----END PGP SIGNATURE----- > From forax at univ-mlv.fr Sat Jun 1 10:57:44 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Sat, 01 Jun 2013 19:57:44 +0200 Subject: lambda expression not expected here In-Reply-To: <51AA2F7E.7040206@petit-huguenin.org> References: <51AA2F7E.7040206@petit-huguenin.org> Message-ID: <51AA3618.8090802@univ-mlv.fr> On 06/01/2013 07:29 PM, Marc Petit-Huguenin wrote: > -----BEGIN PGP SIGNED MESSAGE----- > Hash: SHA256 > > Hi, > > The compilation of this code fails with a "lambda expression not expected > here" error: > > int i = (f -> f + 1).applyAsInt(1); > > I am not sure to understand why this code is invalid as the following code > compiles fine: > > int i = ((IntUnaryOperator)(f -> f + 1)).applyAsInt(1); > > If it is because the compiler cannot infer the type, then perhaps the error > text could be improved. > > Thanks. Hi Marc, no the compiler can not infer the type, there is not enough information. In your example, int i = (f -> f + 1).applyAsInt(1); One lambda can be converted to different functional interfaces, by example, interface IntToIntFun { int fun(int value); } interface Operator { T apply(T value); } so the following statements are both valid: IntToIntFun fun = f -> f + 1; Operator operator = f -> f + 1; There is no way for the compiler to infer the type because they are more than one possible choice. Here, we pay the price that Java has no type for a function and uses the more flexible and more java-like concept of function interface. cheers, R?mi > > - -- > Marc Petit-Huguenin > Email: marc at petit-huguenin.org > Blog: http://blog.marc.petit-huguenin.org > Profile: http://www.linkedin.com/in/petithug > -----BEGIN PGP SIGNATURE----- > Version: GnuPG v1.4.12 (GNU/Linux) > > iQIcBAEBCAAGBQJRqi97AAoJECnERZXWan7E+CsP/14IlYCyFkJsHuP8M1KAp38c > ZGiCqyU2zkKGFdZuMNeslUD25NoLjLpBfNRlk1d4kWZzo+zFWKEnnE/wVJB49zRE > bG4W9iS0ToktODLfDqawPHb4OAEurrqosA3BzUrAy/C7KoOISvvZwVIbXRO/zQi5 > I7/s3G5rb3aN84J6tYjVt0zIKhtBls45slpP+mN9gA8y/u+EZwtQgZc1WhAnKv73 > g5iBCvQK68m9bgj/sCs0W/Y60bRD6vpF3QR26z6mFFfT2Q7ykmSbIb0bF2GteFbr > coRYM/Y6FtmAayPduSbTS3gDS9GuiHnnvJzwuM9Wgd/f/FkbDnhR8wXNdEoXh+ry > klRteAHDzXgOrqHqOfDvWx9JgYqNi7bVw45H8AbsmJj20cdq0Amy8JWEh3iTD6Zy > o6aR0iUpDeQ7Kg+IIn0lzccqBnh6+FKqZqsn5mIpNvPULeHTyu2B54AOUi52Kpez > xDTiioUaRXLZynWpG2AghWTJqc2uZM7T81O+pPSZLPSaHVC7Dde+IU4KG+PvbuHx > 84Rsl7h9wh4pnoxYFcC4WTCinBoF2KZ7MWqT9bUCQGI99FGUvqF4wN76t9tMytbC > YztxzG8q3EHXThxH120dk3HhzyXUj5r4wqmHphH0r9kFN1N8u/Z+lELF4nJa/KCc > BU9BWzp6qbKMt0PSJ7Dl > =YAKJ > -----END PGP SIGNATURE----- > From marc at petit-huguenin.org Sat Jun 1 11:10:56 2013 From: marc at petit-huguenin.org (Marc Petit-Huguenin) Date: Sat, 01 Jun 2013 11:10:56 -0700 Subject: anonymous method call Message-ID: <51AA3930.7050608@petit-huguenin.org> -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 Thanks Brian and R?mi for the response to my previous question. Now that we established my lack of knowledge about the lambda type inference, I have another question, but please note that it is not a suggestion for improvement, merely a question about the limits of what would be possible. A functional interface has only one abstract method, so is there any reason it would not be possible to use an anonymous call to this method? For example: IntUnaryOperator operator = f -> f + 1; and instead of int i = operator.applyAsInt(1); being able to do int i = operator(1); Thanks. - -- Marc Petit-Huguenin Email: marc at petit-huguenin.org Blog: http://blog.marc.petit-huguenin.org Profile: http://www.linkedin.com/in/petithug -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIcBAEBCAAGBQJRqjkuAAoJECnERZXWan7Ea4IP/056K859kyo58iLD3jBpQ2J5 SUgNE/JuBQpj8gBIia5p7iqOcEjjCYxolhTOYaZpuHfDe6/8H9R6YVpPNYOcTyVT trYWwM33Kccoob1k4G31um4aYBbfjWJvBOhZVQvBcLAc2qxF65/lQGPWsrGqtOFo 85Pl2ZAuahGymb6p8GpfSr3gmbPiOCoofh8admgpJSIs80cDAo/E9b43fVr8JAKN M2F8UsZbbzQ9M/mnL37cF5EKlRC4P5rMW0AnzUyYOAoTYRK/ypc4TULaYxuLlBZa t38YdjjQIrUb9FPBrFDLkSfp+nq9fdb7ULUnMBluZTa3OWQ63wfKhum9VQETcS/R h/gzMmMWxf+QF88w/tI0gkFlpgLL89n+OTs0QmByfJVWJbMGtQsfGbMqcOMxNFWh 4n+SLvuHX9fw/kvfsCXL9/QxiYcyWWdCZechu9MQpp9ciOrXm9HxVMIsq61HuiHb yum/Id+17mWgIulTJxODVXm4Dga4gLs8A6eS8ZtXmyn+/6+EWL1q4wjbzrInTTLQ CwP1gDQj3iv5iSg7682Ksahuj85z+oy9lTDEsmkOyk4ASQlohErM3P3ETaIYIjoC wFrIq28g7kBeLZSlUdJL9hsBSYeBCy1+mgXo3R++uhjgYWK+vjg1tLnxKnCskAgk xwHmjjuaDY3UOOtwVAmk =jjhJ -----END PGP SIGNATURE----- From forax at univ-mlv.fr Sat Jun 1 12:32:50 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Sat, 01 Jun 2013 21:32:50 +0200 Subject: anonymous method call In-Reply-To: <51AA3930.7050608@petit-huguenin.org> References: <51AA3930.7050608@petit-huguenin.org> Message-ID: <51AA4C62.401@univ-mlv.fr> On 06/01/2013 08:10 PM, Marc Petit-Huguenin wrote: > -----BEGIN PGP SIGNED MESSAGE----- > Hash: SHA256 > > Thanks Brian and R?mi for the response to my previous question. > > Now that we established my lack of knowledge about the lambda type inference, > I have another question, but please note that it is not a suggestion for > improvement, merely a question about the limits of what would be possible. > > A functional interface has only one abstract method, so is there any reason it > would not be possible to use an anonymous call to this method? > > For example: > > IntUnaryOperator operator = f -> f + 1; > > and instead of > > int i = operator.applyAsInt(1); > > being able to do > > int i = operator(1); > > > Thanks. It's possible to implement that but it exhibits a nasty property given the way Java scope works. In Java, the scope that contains local variables and the one that contains method calls are separated, when the compiler see int i = operator(1); it knowns that this is a method call, and it will not check if there is a local variable named 'operator'. So to support the new syntax and still be able to compile old code, the compiler has to first check if a method is available and then check if a local variable exist if no method was found. This rule is awful because it means that if you add a method in a class (or worst in a super class) you may broke an already existing code because you introduce a method that will be used instead of calling the lambda. so this syntax was rejected by the Expert Group :) cheers, R?mi > > - -- > Marc Petit-Huguenin > Email: marc at petit-huguenin.org > Blog: http://blog.marc.petit-huguenin.org > Profile: http://www.linkedin.com/in/petithug > -----BEGIN PGP SIGNATURE----- > Version: GnuPG v1.4.12 (GNU/Linux) > > iQIcBAEBCAAGBQJRqjkuAAoJECnERZXWan7Ea4IP/056K859kyo58iLD3jBpQ2J5 > SUgNE/JuBQpj8gBIia5p7iqOcEjjCYxolhTOYaZpuHfDe6/8H9R6YVpPNYOcTyVT > trYWwM33Kccoob1k4G31um4aYBbfjWJvBOhZVQvBcLAc2qxF65/lQGPWsrGqtOFo > 85Pl2ZAuahGymb6p8GpfSr3gmbPiOCoofh8admgpJSIs80cDAo/E9b43fVr8JAKN > M2F8UsZbbzQ9M/mnL37cF5EKlRC4P5rMW0AnzUyYOAoTYRK/ypc4TULaYxuLlBZa > t38YdjjQIrUb9FPBrFDLkSfp+nq9fdb7ULUnMBluZTa3OWQ63wfKhum9VQETcS/R > h/gzMmMWxf+QF88w/tI0gkFlpgLL89n+OTs0QmByfJVWJbMGtQsfGbMqcOMxNFWh > 4n+SLvuHX9fw/kvfsCXL9/QxiYcyWWdCZechu9MQpp9ciOrXm9HxVMIsq61HuiHb > yum/Id+17mWgIulTJxODVXm4Dga4gLs8A6eS8ZtXmyn+/6+EWL1q4wjbzrInTTLQ > CwP1gDQj3iv5iSg7682Ksahuj85z+oy9lTDEsmkOyk4ASQlohErM3P3ETaIYIjoC > wFrIq28g7kBeLZSlUdJL9hsBSYeBCy1+mgXo3R++uhjgYWK+vjg1tLnxKnCskAgk > xwHmjjuaDY3UOOtwVAmk > =jjhJ > -----END PGP SIGNATURE----- > From marc at petit-huguenin.org Sat Jun 1 15:11:26 2013 From: marc at petit-huguenin.org (Marc Petit-Huguenin) Date: Sat, 01 Jun 2013 15:11:26 -0700 Subject: anonymous method call In-Reply-To: <51AA4C62.401@univ-mlv.fr> References: <51AA3930.7050608@petit-huguenin.org> <51AA4C62.401@univ-mlv.fr> Message-ID: <51AA718E.8060901@petit-huguenin.org> -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 On 06/01/2013 12:32 PM, Remi Forax wrote: > On 06/01/2013 08:10 PM, Marc Petit-Huguenin wrote: Thanks Brian and R?mi > for the response to my previous question. > > Now that we established my lack of knowledge about the lambda type > inference, I have another question, but please note that it is not a > suggestion for improvement, merely a question about the limits of what > would be possible. > > A functional interface has only one abstract method, so is there any reason > it would not be possible to use an anonymous call to this method? > > For example: > > IntUnaryOperator operator = f -> f + 1; > > and instead of > > int i = operator.applyAsInt(1); > > being able to do > > int i = operator(1); > > > Thanks. > >> It's possible to implement that but it exhibits a nasty property given >> the way Java scope works. > >> In Java, the scope that contains local variables and the one that >> contains method calls are separated, when the compiler see > >> int i = operator(1); > >> it knowns that this is a method call, and it will not check if there is a >> local variable named 'operator'. > >> So to support the new syntax and still be able to compile old code, the >> compiler has to first check if a method is available and then check if a >> local variable exist if no method was found. > >> This rule is awful because it means that if you add a method in a class >> (or worst in a super class) you may broke an already existing code >> because you introduce a method that will be used instead of calling the >> lambda. > >> so this syntax was rejected by the Expert Group :) It makes sense, thanks. FYI, I thought of this when trying to adapt the code in http://www.righto.com/2009/03/y-combinator-in-arc-and-java.html. The result is far simpler than the original code, but I was wondering if there was a way to make it even better: interface HigherOrder extends Function, T> {} Function, IntUnaryOperator> y = r -> ((HigherOrder)(f -> f.apply(f))).apply(f -> r.apply(x -> f.apply(f).applyAsInt(x))); IntUnaryOperator factorial = y.apply(f -> n -> n == 0 ? 1 : n * f.applyAsInt(n - - 1)); assert factorial.applyAsInt(10) == 3628800; IntUnaryOperator fibonacci = y.apply(f -> n -> n == 0 ? 0 : n == 1 ? 1 : f.applyAsInt(n - 1) + f.applyAsInt(n - 2)); assert fibonacci.applyAsInt(30) == 832040; - -- Marc Petit-Huguenin Email: marc at petit-huguenin.org Blog: http://blog.marc.petit-huguenin.org Profile: http://www.linkedin.com/in/petithug -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIcBAEBCAAGBQJRqnGNAAoJECnERZXWan7ELRMP/0/ogTbYxR2QvLOpJVGGruQe /vHnZXo6sVFJQ/tUvCrHua4QA9Mhb3CVHNx1180x3h/QLvi1GdwGBg95mUNnslej k+Kx8y4mTZEugZaYE2dLVUQqDXV7lEZNB/OHyEoGFf6PqjuKZ1WGrUK5WdgzCYnu ctQUeBFouU0zjHo/Im9Pjo2AXYsuc0SaMonGFQhWmbauxZdSG5c074CoEUxxjqCn H1uuy+epJuYBI/66Wc4s+DoCR2OhFz9+ilM1yM6CttDm7xxwtHHaQ2wFdfVisOtT DdI20dz+aF4ACHLy2IhM1jEUGUZdZyQLSZwPS+EPoFt86BafsDLPtgQwB2KE4wHP 4cnyL20PPkIrlnfaG8JHON5+vHxxTIrZ0UjgVXRdpr03scK1eP+OWbHD5J6Ymgp3 TQXntgh7dagNgscadQUZZvfYPV9MvFR/hRCJS3/pCcUflLLiPUZVZq/uBbzYGjJt 9y6NQdaxOKyvrWPwYH6WktPDuNU8pvDQA+TJ5tt2bDW/5P69+2Aibj+YqrnFePyt jhHjJdmE3PhmOLXIcDRgCeyelL6MsXCIUspfCXaqeLp7FBBCp4E9aj8QiQjK0WEW LcR1xei9j35g6PxKzB7R1fgwm2/B83E4DGlukgXixdNW0i5IYjcdODgxaEIy8Ok1 iPNnpdebLHZ/Py9Fa/e1 =tXzk -----END PGP SIGNATURE----- From john.r.rose at oracle.com Sat Jun 1 21:43:20 2013 From: john.r.rose at oracle.com (John Rose) Date: Sat, 1 Jun 2013 23:43:20 -0500 Subject: anonymous method call In-Reply-To: <51AA4C62.401@univ-mlv.fr> References: <51AA3930.7050608@petit-huguenin.org> <51AA4C62.401@univ-mlv.fr> Message-ID: <0C4E5EE7-B169-4BD8-A547-715EA72EA7DB@oracle.com> On Jun 1, 2013, at 2:32 PM, Remi Forax wrote: > This rule is awful because it means that if you add a method in a class > (or worst in a super class) > you may broke an already existing code because you introduce a method > that will be used instead > of calling the lambda. > > so this syntax was rejected by the Expert Group :) OK, this calls for a Devil's Advocate exercise: We did something like this before with an iron-clad compatibility story. Varargs and autobox were compatibly introduced by adding them as post-passes after a presumably failed overloading resolution This rule could also (in principle) be applied to method name resolution, as a post-pass after presumably failed scoping. I.e., if the method name 'foo' in foo(...) cannot be found, then attempt to find a variable name foo, which must then be typed as a functional type (or jli.MethodHandle? or jlr.Method?) and elide the superfluous name (something like 'apply' or 'invoke' or 'applyAsDouble') which is the unique method name for the functional type. ? John From forax at univ-mlv.fr Sun Jun 2 06:07:08 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Sun, 02 Jun 2013 15:07:08 +0200 Subject: anonymous method call In-Reply-To: <0C4E5EE7-B169-4BD8-A547-715EA72EA7DB@oracle.com> References: <51AA3930.7050608@petit-huguenin.org> <51AA4C62.401@univ-mlv.fr> <0C4E5EE7-B169-4BD8-A547-715EA72EA7DB@oracle.com> Message-ID: <51AB437C.3020709@univ-mlv.fr> On 06/02/2013 06:43 AM, John Rose wrote: > On Jun 1, 2013, at 2:32 PM, Remi Forax > wrote: > >> This rule is awful because it means that if you add a method in a class >> (or worst in a super class) >> you may broke an already existing code because you introduce a method >> that will be used instead >> of calling the lambda. >> >> so this syntax was rejected by the Expert Group :) > > OK, this calls for a Devil's Advocate exercise: > > We did something like this before with an iron-clad compatibility > story. Varargs and autobox were compatibly introduced by adding them > as post-passes after a presumably failed overloading resolution > > This rule could also (in principle) be applied to method name > resolution, as a post-pass after presumably failed scoping. > > I.e., if the method name 'foo' in foo(...) cannot be found, then > attempt to find a variable name foo, which must then be typed as a > functional type (or jli.MethodHandle? or jlr.Method?) and elide the > superfluous name (something like 'apply' or 'invoke' or > 'applyAsDouble') which is the unique method name for the functional type. yes, it can be done. But it's not because it can be done that it should be done, as usual the devil is in the details :) The rules to choose the applicable methods when doing the overload resolution only deals with methods, so if someone introduces a new method in a class, it's easy to see if it will create a compatibility issue or not, so it's something which is manageable. Note that the compatibility can be broken without boxing and varargs just by inserting an overload that is more specific than an existing one. Juggling between scopes in backward order is not something 'like this'. Trying to first lookup in the method scope which is more global to then fallback to the local variable scope (which is more local) has the nasty property that you have no way to know if introducing a method will or not break the source compatibility. Having a lambda typed by a jli.MethodHandle or a jlr.Method is another story. > > ? John R?mi From forax at univ-mlv.fr Sun Jun 2 06:33:20 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Sun, 02 Jun 2013 15:33:20 +0200 Subject: anonymous method call In-Reply-To: <51AA718E.8060901@petit-huguenin.org> References: <51AA3930.7050608@petit-huguenin.org> <51AA4C62.401@univ-mlv.fr> <51AA718E.8060901@petit-huguenin.org> Message-ID: <51AB49A0.3080103@univ-mlv.fr> On 06/02/2013 12:11 AM, Marc Petit-Huguenin wrote: > -----BEGIN PGP SIGNED MESSAGE----- > Hash: SHA256 > > On 06/01/2013 12:32 PM, Remi Forax wrote: >> On 06/01/2013 08:10 PM, Marc Petit-Huguenin wrote: Thanks Brian and R?mi >> for the response to my previous question. >> >> Now that we established my lack of knowledge about the lambda type >> inference, I have another question, but please note that it is not a >> suggestion for improvement, merely a question about the limits of what >> would be possible. >> >> A functional interface has only one abstract method, so is there any reason >> it would not be possible to use an anonymous call to this method? >> >> For example: >> >> IntUnaryOperator operator = f -> f + 1; >> >> and instead of >> >> int i = operator.applyAsInt(1); >> >> being able to do >> >> int i = operator(1); >> >> >> Thanks. >> >>> It's possible to implement that but it exhibits a nasty property given >>> the way Java scope works. >>> In Java, the scope that contains local variables and the one that >>> contains method calls are separated, when the compiler see >>> int i = operator(1); >>> it knowns that this is a method call, and it will not check if there is a >>> local variable named 'operator'. >>> So to support the new syntax and still be able to compile old code, the >>> compiler has to first check if a method is available and then check if a >>> local variable exist if no method was found. >>> This rule is awful because it means that if you add a method in a class >>> (or worst in a super class) you may broke an already existing code >>> because you introduce a method that will be used instead of calling the >>> lambda. >>> so this syntax was rejected by the Expert Group :) > It makes sense, thanks. > > FYI, I thought of this when trying to adapt the code in > http://www.righto.com/2009/03/y-combinator-in-arc-and-java.html. The result > is far simpler than the original code, but I was wondering if there was a way > to make it even better: > > interface HigherOrder extends Function, T> {} > > Function, IntUnaryOperator> y = r -> > ((HigherOrder)(f -> f.apply(f))).apply(f -> r.apply(x -> > f.apply(f).applyAsInt(x))); > IntUnaryOperator factorial = y.apply(f -> n -> n == 0 ? 1 : n * f.applyAsInt(n > - - 1)); > assert factorial.applyAsInt(10) == 3628800; > IntUnaryOperator fibonacci = y.apply(f -> n -> n == 0 ? 0 : n == 1 ? 1 : > f.applyAsInt(n - 1) + f.applyAsInt(n - 2)); > assert fibonacci.applyAsInt(30) == 832040; Apart from adding a local variable for f -> f.apply(f) to avoid the cast and make the code a little more readable, I don't think so but maybe I'm wrong. Function, IntUnaryOperator> y = r -> { HigherOrder hop = f -> f.apply(f); return hop.apply(f -> r.apply(x -> f.apply(f).applyAsInt(x))); }; IntUnaryOperator factorial = y.apply(f -> n -> n == 0 ? 1 : n * f.applyAsInt(n - 1)); System.out.println(factorial.applyAsInt(10)); // 3628800; IntUnaryOperator fibonacci = y.apply(f -> n -> n == 0 ? 0 : n == 1 ? 1 : f.applyAsInt(n - 1) + f.applyAsInt(n - 2)); System.out.println(fibonacci.applyAsInt(30)); // 832040; cheers, R?mi > > - -- > Marc Petit-Huguenin > Email: marc at petit-huguenin.org > Blog: http://blog.marc.petit-huguenin.org > Profile: http://www.linkedin.com/in/petithug > -----BEGIN PGP SIGNATURE----- > Version: GnuPG v1.4.12 (GNU/Linux) > > iQIcBAEBCAAGBQJRqnGNAAoJECnERZXWan7ELRMP/0/ogTbYxR2QvLOpJVGGruQe > /vHnZXo6sVFJQ/tUvCrHua4QA9Mhb3CVHNx1180x3h/QLvi1GdwGBg95mUNnslej > k+Kx8y4mTZEugZaYE2dLVUQqDXV7lEZNB/OHyEoGFf6PqjuKZ1WGrUK5WdgzCYnu > ctQUeBFouU0zjHo/Im9Pjo2AXYsuc0SaMonGFQhWmbauxZdSG5c074CoEUxxjqCn > H1uuy+epJuYBI/66Wc4s+DoCR2OhFz9+ilM1yM6CttDm7xxwtHHaQ2wFdfVisOtT > DdI20dz+aF4ACHLy2IhM1jEUGUZdZyQLSZwPS+EPoFt86BafsDLPtgQwB2KE4wHP > 4cnyL20PPkIrlnfaG8JHON5+vHxxTIrZ0UjgVXRdpr03scK1eP+OWbHD5J6Ymgp3 > TQXntgh7dagNgscadQUZZvfYPV9MvFR/hRCJS3/pCcUflLLiPUZVZq/uBbzYGjJt > 9y6NQdaxOKyvrWPwYH6WktPDuNU8pvDQA+TJ5tt2bDW/5P69+2Aibj+YqrnFePyt > jhHjJdmE3PhmOLXIcDRgCeyelL6MsXCIUspfCXaqeLp7FBBCp4E9aj8QiQjK0WEW > LcR1xei9j35g6PxKzB7R1fgwm2/B83E4DGlukgXixdNW0i5IYjcdODgxaEIy8Ok1 > iPNnpdebLHZ/Py9Fa/e1 > =tXzk > -----END PGP SIGNATURE----- From paul.sandoz at oracle.com Mon Jun 3 02:49:23 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Mon, 03 Jun 2013 09:49:23 +0000 Subject: hg: lambda/lambda/jdk: Rename Spliterators.iteratorFromSpliterator to Spliterators.iterator. Message-ID: <20130603094951.6683248ED6@hg.openjdk.java.net> Changeset: 9cdd4519bf4c Author: psandoz Date: 2013-06-03 11:49 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/9cdd4519bf4c Rename Spliterators.iteratorFromSpliterator to Spliterators.iterator. ! src/share/classes/java/util/Spliterators.java ! src/share/classes/java/util/stream/DoublePipeline.java ! src/share/classes/java/util/stream/IntPipeline.java ! src/share/classes/java/util/stream/LongPipeline.java ! src/share/classes/java/util/stream/ReferencePipeline.java ! src/share/classes/java/util/stream/SpinedBuffer.java ! test/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java ! test/java/util/stream/bootlib/java/util/stream/TestData.java ! test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java ! test/java/util/stream/boottest/java/util/stream/IntNodeTest.java ! test/java/util/stream/boottest/java/util/stream/LongNodeTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTraversingAndSplittingTest.java From paul.sandoz at oracle.com Mon Jun 3 02:59:45 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Mon, 03 Jun 2013 09:59:45 +0000 Subject: hg: lambda/lambda/jdk: Remove duplicate tests present in test/java/util/Spliterator Message-ID: <20130603095957.A9F3348ED7@hg.openjdk.java.net> Changeset: e08513aeb316 Author: psandoz Date: 2013-06-03 11:59 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e08513aeb316 Remove duplicate tests present in test/java/util/Spliterator - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorLateBindingFailFastTest.java - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTraversingAndSplittingTest.java From paul.sandoz at oracle.com Mon Jun 3 03:59:29 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Mon, 03 Jun 2013 10:59:29 +0000 Subject: hg: lambda/lambda/jdk: Mark as final. Message-ID: <20130603105942.6B16C48EDB@hg.openjdk.java.net> Changeset: bf375a39615e Author: psandoz Date: 2013-06-03 12:56 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bf375a39615e Mark as final. This class should be reverted back to package private if public static methods are moved elsewhere. ! src/share/classes/java/util/stream/Streams.java From boaznahum at gmail.com Mon Jun 3 12:24:03 2013 From: boaznahum at gmail.com (Boaz Nahum) Date: Mon, 3 Jun 2013 22:24:03 +0300 Subject: Optional.ifPresent Message-ID: Can ifPresent return boolean. In some cases it will save double check (like in tryAdvance). Thanks Boaz From henry.jen at oracle.com Mon Jun 3 13:02:55 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Mon, 03 Jun 2013 20:02:55 +0000 Subject: hg: lambda/lambda/jdk: Minor cleanup Message-ID: <20130603200318.D6B5048EFB@hg.openjdk.java.net> Changeset: 0d539fe83277 Author: henryjen Date: 2013-06-03 13:02 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0d539fe83277 Minor cleanup ! src/share/classes/java/lang/CharSequence.java From henry.jen at oracle.com Mon Jun 3 13:33:01 2013 From: henry.jen at oracle.com (Henry Jen) Date: Mon, 03 Jun 2013 13:33:01 -0700 Subject: RFR: 8015522 - CharSequence.codePoints can be faster Message-ID: <51ACFD7D.6020208@oracle.com> Hi, Please review http://cr.openjdk.java.net/~henryjen/tl/8015522.0/webrev/ This webrev is based on previous suggestion from Martin Buchholz while keep the lazy-binding nature without seize the length at construction time. The benchmark shows ~50% performance increase, mainly from reduce of operation, for example, inline block.accept instead of store the character to a local var also helps. Cheers, Henry From martinrb at google.com Mon Jun 3 13:42:58 2013 From: martinrb at google.com (Martin Buchholz) Date: Mon, 3 Jun 2013 13:42:58 -0700 Subject: RFR: 8015522 - CharSequence.codePoints can be faster In-Reply-To: <51ACFD7D.6020208@oracle.com> References: <51ACFD7D.6020208@oracle.com> Message-ID: Thanks for the optimization (especially the benchmarking!). Looks Good To Me. On Mon, Jun 3, 2013 at 1:33 PM, Henry Jen wrote: > Hi, > > Please review > http://cr.openjdk.java.net/~henryjen/tl/8015522.0/webrev/ > > This webrev is based on previous suggestion from Martin Buchholz while > keep the lazy-binding nature without seize the length at construction time. > > The benchmark shows ~50% performance increase, mainly from reduce of > operation, for example, inline block.accept instead of store the > character to a local var also helps. > > Cheers, > Henry > From samir at noodlesandwich.com Mon Jun 3 13:47:41 2013 From: samir at noodlesandwich.com (Samir Talwar) Date: Mon, 3 Jun 2013 21:47:41 +0100 Subject: Optional.ifPresent In-Reply-To: References: Message-ID: I'd quite like to see an example of where this is useful. I can't visualise it, personally. ? Samir. On 3 Jun 2013 20:41, "Boaz Nahum" wrote: > Can ifPresent return boolean. > > In some cases it will save double check (like in tryAdvance). > > Thanks > Boaz > > From henry.jen at oracle.com Mon Jun 3 14:33:28 2013 From: henry.jen at oracle.com (Henry Jen) Date: Mon, 03 Jun 2013 14:33:28 -0700 Subject: Comparator/Comparators API change proposal Message-ID: <51AD0BA8.1050007@oracle.com> Hi, Static interface method support has being available for a while, it seems reasonable to move a couple methods from Comparators into Comparator. Also it is recommended to rename Function-variant comparing to according primitive type to eliminate ambiguity for lambda cases like following, Comparator comparing(Function f); Comparator comparing(ToIntFunction f); Comparator c = comparing(s -> s.size()); So here is what we are proposing, 1. Move all Comparators.comparing to Comparator.comparing 2. Rename various comparing methods to comparing, comparingInt, comparingLong and comparingDouble accordingly. 3. Same renaming apply to Comparator.thenComparing Other than that, we have 1. move Comparators.naturalOrder() and reverseOrder() to Comparator. Basically, static factory method should be in Comparator. Convenient helper/combinator methods such as byKey/byValue should be in Comparators. 2. rename Comparator.reverseOrder() default method to reverse(), it's simply reverse form of the comparator. 3. Add nullsFirst(Comparator cmp) and nullsLast(Comparator cmp) into Comparators as helper function to wrap up a comparator to be null-friendly. Specdiff can be found at http://cr.openjdk.java.net/~henryjen/ccc/8009736.1/specdiff Thoughts? Cheers, Henry From zhong.j.yu at gmail.com Mon Jun 3 21:21:54 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Mon, 3 Jun 2013 23:21:54 -0500 Subject: Forget Optional, adopt Try? Message-ID: I'm thinking that if we have something like scala's Try, it'll express APIs' intentions better than Optional. Some people view Optional as a collection of either 0 or 1 element. That doesn't seem to be what an API author wants to express by returning an Optional. The actual intention is that, either the action succeeds with a value (not a collection of!), or it fails (with an unspecified or implied reason). Try describes that intention precisely (but it probably needs a better name) Suppose we have a good old method that returns a nullable /** return null if there's no element */ T getFirst(); Why do we hate it? Probably because we need to insert null handling in the code path T first = getFirst(); if(first==null) blah blah first.doSomething()... we would rather defer null handling to some later time, leaving the main code path cleaner. Java already has a way to do that - exception propagation. For example the method can be designed to throw T getFirst() throw NotFoundExcpetion; // for efficiency, throw a cached immutable exception object T first = getFirst(); // may throw - exception will be handled somewhere else // no null handling here first.doSomething() But lots of try-catch blocks may make code look ugly. Try may be nicer /** fail with NotFoundException if there's no element */ Try getFirst(); Try first = getFirst(); first.map().filter().recover().... So we don't need Optional. Try does the same thing, and expresses the intention better. And Try has broader use cases. It'll also appease those who prefer returning errors over throwing errors. Sounds good? Zhong Yu From henry.jen at oracle.com Mon Jun 3 21:48:59 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Tue, 04 Jun 2013 04:48:59 +0000 Subject: hg: lambda/lambda/jdk: 8009736: Comparators/Comparator API refactoring Message-ID: <20130604044931.B97D848F15@hg.openjdk.java.net> Changeset: d59ddbb18a2d Author: henryjen Date: 2013-06-03 21:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/d59ddbb18a2d 8009736: Comparators/Comparator API refactoring ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Comparators.java ! src/share/classes/java/util/stream/Collector.java ! src/share/classes/java/util/stream/Collectors.java ! test/java/util/Comparator/BasicTest.java ! test/java/util/Comparators/BasicTest.java From jed at wesleysmith.io Tue Jun 4 00:52:26 2013 From: jed at wesleysmith.io (Jed Wesley-Smith) Date: Tue, 4 Jun 2013 17:52:26 +1000 Subject: Forget Optional, adopt Try? In-Reply-To: References: Message-ID: Actually Try is a (sort of*) monad on exception handling. It is really an Either (or disjunction) class that is specialised to catch exceptions during map/flatMap. As you point out, Option is isomorphic to an Either with no useful value on the left hand side (Unit or Void for instance), and a true Either can return something meaningful as to the reason why there was nothing. Making something that was returning @Nullable T an Optional simply says to the client, "there may not be a return value here". Making it return an Either says to the client "there may not be a return value here and X is why". This is actually not necessary in many cases. Imagine a Map.getOptional, there is no real reason to supply BecauseThisMapDidntContainValue on the left hand side if the key isn't found? it is somewhat obvious. So, while Either and Option to serve similar purposes, there are important differences. Rather than choose one, you really want to have both in the kit. cheers, jed. * it is sort of a monad as a monad should really obey the contravariant functor laws, and it doesn't due to the fact that composition is violated: https://issues.scala-lang.org/browse/SI-6284 On 4 June 2013 14:21, Zhong Yu wrote: > I'm thinking that if we have something like scala's Try, it'll > express APIs' intentions better than Optional. > > Some people view Optional as a collection of either 0 or 1 element. > That doesn't seem to be what an API author wants to express by > returning an Optional. The actual intention is that, either the action > succeeds with a value (not a collection of!), or it fails (with an > unspecified or implied reason). Try describes that intention > precisely (but it probably needs a better name) > > Suppose we have a good old method that returns a nullable > > /** return null if there's no element */ > T getFirst(); > > Why do we hate it? Probably because we need to insert null handling in > the code path > > T first = getFirst(); > if(first==null) > blah blah > first.doSomething()... > > we would rather defer null handling to some later time, leaving the > main code path cleaner. Java already has a way to do that - exception > propagation. For example the method can be designed to throw > > T getFirst() throw NotFoundExcpetion; > // for efficiency, throw a cached immutable exception object > > T first = getFirst(); // may throw - exception will be handled > somewhere else > // no null handling here > first.doSomething() > > But lots of try-catch blocks may make code look ugly. Try may be nicer > > /** fail with NotFoundException if there's no element */ > Try getFirst(); > > Try first = getFirst(); > first.map().filter().recover().... > > So we don't need Optional. Try does the same thing, and expresses > the intention better. And Try has broader use cases. It'll also > appease those who prefer returning errors over throwing errors. > > Sounds good? > > Zhong Yu > > From paul.sandoz at oracle.com Tue Jun 4 01:21:48 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Tue, 4 Jun 2013 10:21:48 +0200 Subject: Forget Optional, adopt Try? In-Reply-To: References: Message-ID: On Jun 4, 2013, at 6:21 AM, Zhong Yu wrote: > I'm thinking that if we have something like scala's Try, it'll > express APIs' intentions better than Optional. > > Some people view Optional as a collection of either 0 or 1 element. > That doesn't seem to be what an API author wants to express by > returning an Optional. The actual intention is that, either the action > succeeds with a value (not a collection of!), or it fails (with an > unspecified or implied reason). The intention is whether the terminal operation returned a result or not, perhaps because the stream is empty or because the given the search criterea no result matched (although it is only the former which occurs at the moment), rather than because of some error specified or otherwise. I like the concept of Try but in the context of a replacement for Optional i think it just muddies the waters. Paul. From paul.sandoz at oracle.com Tue Jun 4 01:36:56 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Tue, 4 Jun 2013 10:36:56 +0200 Subject: RFR: 8015522 - CharSequence.codePoints can be faster In-Reply-To: <51ACFD7D.6020208@oracle.com> References: <51ACFD7D.6020208@oracle.com> Message-ID: <0780B0DD-071E-42FE-900D-8C2F3A7BF899@oracle.com> On Jun 3, 2013, at 10:33 PM, Henry Jen wrote: > Hi, > > Please review > http://cr.openjdk.java.net/~henryjen/tl/8015522.0/webrev/ > > This webrev is based on previous suggestion from Martin Buchholz while > keep the lazy-binding nature without seize the length at construction time. > > The benchmark shows ~50% performance increase, mainly from reduce of > operation, for example, inline block.accept instead of store the > character to a local var also helps. > Looks good. Paul. From scolebourne at joda.org Tue Jun 4 02:10:22 2013 From: scolebourne at joda.org (Stephen Colebourne) Date: Tue, 4 Jun 2013 10:10:22 +0100 Subject: Comparator/Comparators API change proposal In-Reply-To: <51AD0BA8.1050007@oracle.com> References: <51AD0BA8.1050007@oracle.com> Message-ID: On 3 June 2013 22:33, Henry Jen wrote: > 2. rename Comparator.reverseOrder() default method to reverse(), it's > simply reverse form of the comparator. I would recommend reversed(). reverse() implies you are changing a property of the comparator, in a mutable style. reversed() implies that you are returning a new comparator in an immutable style. list.sort( comparing(Person::getLastName).reversed() ); See "past tense" in http://blog.joda.org/2011/08/common-java-method-names.html Stephen From Alan.Bateman at oracle.com Tue Jun 4 02:19:04 2013 From: Alan.Bateman at oracle.com (Alan Bateman) Date: Tue, 04 Jun 2013 10:19:04 +0100 Subject: RFR: 8015522 - CharSequence.codePoints can be faster In-Reply-To: <51ACFD7D.6020208@oracle.com> References: <51ACFD7D.6020208@oracle.com> Message-ID: <51ADB108.7080800@oracle.com> On 03/06/2013 21:33, Henry Jen wrote: > Hi, > > Please review > http://cr.openjdk.java.net/~henryjen/tl/8015522.0/webrev/ > > This webrev is based on previous suggestion from Martin Buchholz while > keep the lazy-binding nature without seize the length at construction time. > > The benchmark shows ~50% performance increase, mainly from reduce of > operation, for example, inline block.accept instead of store the > character to a local var also helps. > > Cheers, > Henry Looks good to me too. -Alan. From sergey.kuksenko at oracle.com Tue Jun 4 03:41:54 2013 From: sergey.kuksenko at oracle.com (Sergey Kuksenko) Date: Tue, 04 Jun 2013 14:41:54 +0400 Subject: RFR: 8015522 - CharSequence.codePoints can be faster In-Reply-To: <51ACFD7D.6020208@oracle.com> References: <51ACFD7D.6020208@oracle.com> Message-ID: <51ADC472.7070807@oracle.com> Hi JavaDoc to the method says: "If the sequence is mutated while the stream is being read, the result is undefined." What about exceptions? If the sequence is mutated and length becomes smaller you'll get IndexOutOfBoundsException in forEachRemaining method. On 06/04/2013 12:33 AM, Henry Jen wrote: > Hi, > > Please review > http://cr.openjdk.java.net/~henryjen/tl/8015522.0/webrev/ > > This webrev is based on previous suggestion from Martin Buchholz while > keep the lazy-binding nature without seize the length at construction time. > > The benchmark shows ~50% performance increase, mainly from reduce of > operation, for example, inline block.accept instead of store the > character to a local var also helps. > > Cheers, > Henry > -- Best regards, Sergey Kuksenko From christian.mallwitz at Commerzbank.com Tue Jun 4 05:02:13 2013 From: christian.mallwitz at Commerzbank.com (Mallwitz, Christian) Date: Tue, 4 Jun 2013 14:02:13 +0200 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: Hi, Re-reporting problem for build 92: the filter/limit on unbound, parallel stream operation behaves very weird. How weird? Well: - the serial version uses about 16M of heap, the parallel gobbles up all of the 1GB defined as max - it throws an OOM after running for hours while it is __NOT__ garbage collecting much but - the filter predicate is called on millions of elements more than what can be observed using a serial stream - I can't observe any parallelism (based on number of cores and system load - 4 cores and only 25% load) I'm using 1.8.0-ea-lambda-nightly-h4544-20130526-b92-b00 on a Windows XP 32 bit machine - VM args: -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps My test program tries to find the first 283,146 prime numbers (which are all below 4,000,000). It executes the filter/limit operation on a serial stream first and prints out numbers tested for primality occasionally. Thanks Christian package com.snuffbumble.lambda; import java.util.stream.LongStream; import java.util.stream.Stream; public class OOM { public static void main(String... ignored) { // first 283_146 primes are all < 4_000_000 firstNPrimes(283_146, getIteratorBasedStream(false)); // only minor GC - max heap 16M firstNPrimes(283_146, getIteratorBasedStream(true)); // full GC - up to max heap 1GB and subsequent OOM } private static Stream getIteratorBasedStream(boolean produceParallelStream) { Stream s = LongStream.iterate(1L, n -> n + 1L).boxed(); return produceParallelStream ? s.parallel() : s; } private static void firstNPrimes(int n, Stream stream) { System.out.println(String.format("firstNPrimes (%8d, %5b): %8d", n, stream.isParallel(), stream .filter(OOM::isPrime) .limit(n) // limit after primality test .count())); } private static long start_millis = System.currentTimeMillis(); private static long max_n_seen = 3_999_970L; private static boolean isPrime(long n) { if (n >= max_n_seen) { System.out.println(String.format("%.3f: %d", (System.currentTimeMillis() - start_millis)/1000.0, n)); max_n_seen = n + (n/20L); // new max_n_seen 5% larger than current n } if (n <= 1) { return false; } if (n == 2) { return true; } if (n % 2 == 0) { return false; } for (int i = 3; i <= (int) Math.sqrt(n); i += 2) { if (n % i == 0) return false; } return true; } } From john at milsson.nu Tue Jun 4 05:08:21 2013 From: john at milsson.nu (John Nilsson) Date: Tue, 4 Jun 2013 14:08:21 +0200 Subject: Forget Optional, adopt Try? In-Reply-To: References: Message-ID: <53183E22-02B3-4042-A989-DBE4F75E2EBF@milsson.nu> Optional also makes for a better input type if you really mean to take an optional value. Would it make senare to establish type hierarchy? (Wether by subtyping or implicits) Such that Try <: Either <: Option BR John Skickat fr?n min iPhone 4 jun 2013 kl. 09:52 skrev Jed Wesley-Smith : > Actually Try is a (sort of*) monad on exception handling. It is really an > Either (or disjunction) class that is specialised to catch exceptions > during map/flatMap. > > As you point out, Option is isomorphic to an Either with no useful value on > the left hand side (Unit or Void for instance), and a true Either can > return something meaningful as to the reason why there was nothing. > > Making something that was returning @Nullable T an Optional simply says > to the client, "there may not be a return value here". Making it return an > Either says to the client "there may not be a return value here and X > is why". This is actually not necessary in many cases. Imagine a > Map.getOptional, there is no real reason to supply > BecauseThisMapDidntContainValue on the left hand side if the key isn't > found? it is somewhat obvious. > > So, while Either and Option to serve similar purposes, there are important > differences. Rather than choose one, you really want to have both in the > kit. > > cheers, > jed. > > * it is sort of a monad as a monad should really obey the contravariant > functor laws, and it doesn't due to the fact that composition is violated: > https://issues.scala-lang.org/browse/SI-6284 > > > On 4 June 2013 14:21, Zhong Yu wrote: > >> I'm thinking that if we have something like scala's Try, it'll >> express APIs' intentions better than Optional. >> >> Some people view Optional as a collection of either 0 or 1 element. >> That doesn't seem to be what an API author wants to express by >> returning an Optional. The actual intention is that, either the action >> succeeds with a value (not a collection of!), or it fails (with an >> unspecified or implied reason). Try describes that intention >> precisely (but it probably needs a better name) >> >> Suppose we have a good old method that returns a nullable >> >> /** return null if there's no element */ >> T getFirst(); >> >> Why do we hate it? Probably because we need to insert null handling in >> the code path >> >> T first = getFirst(); >> if(first==null) >> blah blah >> first.doSomething()... >> >> we would rather defer null handling to some later time, leaving the >> main code path cleaner. Java already has a way to do that - exception >> propagation. For example the method can be designed to throw >> >> T getFirst() throw NotFoundExcpetion; >> // for efficiency, throw a cached immutable exception object >> >> T first = getFirst(); // may throw - exception will be handled >> somewhere else >> // no null handling here >> first.doSomething() >> >> But lots of try-catch blocks may make code look ugly. Try may be nicer >> >> /** fail with NotFoundException if there's no element */ >> Try getFirst(); >> >> Try first = getFirst(); >> first.map().filter().recover().... >> >> So we don't need Optional. Try does the same thing, and expresses >> the intention better. And Try has broader use cases. It'll also >> appease those who prefer returning errors over throwing errors. >> >> Sounds good? >> >> Zhong Yu > From paul.sandoz at oracle.com Tue Jun 4 07:17:28 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Tue, 4 Jun 2013 16:17:28 +0200 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: Hi Christian, I can reproduce your behaviour of your test programming taking ages to run, but i needed to increase mx to 2g. Initially i notice lots of GCs then it starts slowing down with the occasional "GC (Allocation Failure)". Something fishy is going on here, it is very slow with one core pegged at 100% and Visual VM is showing that the used heap is way less than the heap size. If i run using interpretive mode -Xint, it works fine, suggesting we are running into a hotspot issue, perhaps a hotspot/GC issue: $ java -Xint -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps OOM2 -XX:ClassMetaspaceSize=104857600 -XX:InitialHeapSize=134217728 -XX:MaxHeapSize=1073741824 -XX:+PrintCommandLineFlags -XX:+PrintGC -XX:+PrintGCTimeStamps -XX:+UseCompressedKlassPointers -XX:+UseCompressedOops -XX:+UseParallelGC 3.766: [GC (Allocation Failure) 32767K->656K(125632K), 0.0010730 secs] 8.476: [GC (Allocation Failure) 33424K->592K(125632K), 0.0008800 secs] 13.520: 3999970 firstNPrimes ( 283146, false): 283146 13.623: [GC (Allocation Failure) 33360K->960K(125632K), 0.0010140 secs] 14.019: [GC (Allocation Failure) 33728K->6244K(125632K), 0.0035470 secs] 14.530: [GC (Allocation Failure) 39004K->11608K(124864K), 0.0050110 secs] 15.034: [GC (Allocation Failure) 43608K->23289K(123776K), 0.0071630 secs] 15.499: [GC (Allocation Failure) 48175K->27989K(129600K), 0.0033540 secs] 15.946: [GC (Allocation Failure) 53141K->38138K(126336K), 0.0083030 secs] 15.878: 4199968 16.043: 4475905 16.416: [GC (Allocation Failure) 57018K->24262K(111040K), 0.0027570 secs] firstNPrimes ( 283146, true): 283146 From the GC output it looks like an ~ speed up of about 3-4x. I can even run with a lower mx value. Interestingly if i lower mx to say 32m i start running into similar issues. I have noticed GC output continually outputting a full GC. -- Because iterator is an ordered and infinite source then hooking it up to limit will always requiring buffering when going parallel. We have managed to reduce some of the internal memory churn but this really comes down to better documentation. To obtain 283_146 primes at least 3_999_971 elements will need to be buffered. The LongStream.iterate method extracts parallelism by sequentially copying a prefix of elements into an array and growing the array over time. Each array will be operated on by an F/J task. To get any parallel speed up the cost of processing elements must be higher than copying those elements into an array; i think primes is a good example of where this should work well. Note that a limit up to N does not guarantee that up to N elements will be processed upstream, it may be more, specially so given the array sizes increasing of iterate. Using boxed values is definitely gonna kill performance since it will mess up the caches, while the array of Long[] is OK the actually long values could be anywhere in memory. Paul. On Jun 4, 2013, at 2:02 PM, "Mallwitz, Christian" wrote: > Hi, > > Re-reporting problem for build 92: the filter/limit on unbound, parallel stream operation behaves very weird. How weird? Well: > > - the serial version uses about 16M of heap, the parallel gobbles up all of the 1GB defined as max > - it throws an OOM after running for hours while it is __NOT__ garbage collecting much but > - the filter predicate is called on millions of elements more than what can be observed using a serial stream > - I can't observe any parallelism (based on number of cores and system load - 4 cores and only 25% load) > > I'm using 1.8.0-ea-lambda-nightly-h4544-20130526-b92-b00 on a Windows XP 32 bit machine - VM args: -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps > > My test program tries to find the first 283,146 prime numbers (which are all below 4,000,000). It executes the filter/limit operation on a serial stream first and prints out numbers tested for primality occasionally. > > Thanks > Christian > > > > > > package com.snuffbumble.lambda; > > import java.util.stream.LongStream; > import java.util.stream.Stream; > > public class OOM { > > public static void main(String... ignored) { > > // first 283_146 primes are all < 4_000_000 > > firstNPrimes(283_146, getIteratorBasedStream(false)); // only minor GC - max heap 16M > firstNPrimes(283_146, getIteratorBasedStream(true)); // full GC - up to max heap 1GB and subsequent OOM > } > > private static Stream getIteratorBasedStream(boolean produceParallelStream) { > Stream s = LongStream.iterate(1L, n -> n + 1L).boxed(); > return produceParallelStream ? s.parallel() : s; > } > > private static void firstNPrimes(int n, Stream stream) { > System.out.println(String.format("firstNPrimes (%8d, %5b): %8d", n, stream.isParallel(), > stream > .filter(OOM::isPrime) > .limit(n) // limit after primality test > .count())); > } > > private static long start_millis = System.currentTimeMillis(); > private static long max_n_seen = 3_999_970L; > > private static boolean isPrime(long n) { > > if (n >= max_n_seen) { > System.out.println(String.format("%.3f: %d", (System.currentTimeMillis() - start_millis)/1000.0, n)); > max_n_seen = n + (n/20L); // new max_n_seen 5% larger than current n > } > > if (n <= 1) { return false; } > if (n == 2) { return true; } > if (n % 2 == 0) { return false; } > for (int i = 3; i <= (int) Math.sqrt(n); i += 2) { if (n % i == 0) return false; } > return true; > } > } > > From aleksey.shipilev at oracle.com Tue Jun 4 07:46:18 2013 From: aleksey.shipilev at oracle.com (Aleksey Shipilev) Date: Tue, 04 Jun 2013 18:46:18 +0400 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: <51ADFDBA.30405@oracle.com> On 06/04/2013 06:17 PM, Paul Sandoz wrote: > If i run using interpretive mode -Xint, it works fine, suggesting we > are running into a hotspot issue, perhaps a hotspot/GC issue: I had reproduced this as well, and seeing java.util.stream.SliceOps$SliceTask -> java.util.Spliterators$LongArraySpliterator -> long[] ...occupying the most of the heap (3 Gb on my machine). It passes with -Xmx7g without problems. With lower heaps, it does a series of full GC, which end up with: [Full GC (Ergonomics) [PSYoungGen: 557248K->555317K(901760K)] [ParOldGen: 4190056K->4190056K(4194304K)] 4747304K->4745374K(5096064K), [Metaspace: 4142K->4702K(110592K)], 0.0800150 secs] [Times: user=0.19 sys=0.00, real=0.08 secs] [Full GC (Ergonomics) [PSYoungGen: 557248K->0K(901760K)] [ParOldGen: 4190056K->20912K(1710848K)] 4747304K->20912K(2612608K), [Metaspace: 4144K->4702K(110592K)], 0.2308390 secs] [Times: user=0.15 sys=0.16, real=0.23 secs] ...so the heap appears to be empty. The application is still munching through data in the main thread, which explains why there is no parallelism happening: "main" #1 prio=5 os_prio=0 tid=0x00007fa290009800 nid=0x7342 runnable [0x00007fa298ed1000] java.lang.Thread.State: RUNNABLE at java.util.stream.Nodes$SpinedNodeBuilder.accept(Nodes.java:1248) at java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:176) at java.util.stream.LongPipeline$3$1.accept(LongPipeline.java:230) at java.util.PrimitiveIterator$OfLong.forEachRemaining(PrimitiveIterator.java:166) at java.util.stream.LongStream$1.forEachRemaining(LongStream.java) at java.util.Spliterators$LongIteratorSpliterator.forEachRemaining(Spliterators.java:2029) at java.util.Spliterator$OfLong.forEachRemaining(Spliterator.java:744) at java.util.Spliterators$LongIteratorSpliterator.forEachRemaining(Spliterators.java) at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482) at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472) at java.util.stream.SliceOps$SliceTask.doLeaf(SliceOps.java:606) at java.util.stream.SliceOps$SliceTask.doLeaf(SliceOps.java:553) at java.util.stream.AbstractTask.compute(AbstractTask.java:312) at java.util.concurrent.CountedCompleter.exec(CountedCompleter.java:710) at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289) at java.util.concurrent.ForkJoinTask.doInvoke(ForkJoinTask.java:385) at java.util.concurrent.ForkJoinTask.invoke(ForkJoinTask.java:717) at java.util.stream.SliceOps$1.opEvaluateParallelLazy(SliceOps.java:150) at java.util.stream.AbstractPipeline.sourceSpliterator(AbstractPipeline.java:442) at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:230) at java.util.stream.LongPipeline.reduce(LongPipeline.java:447) at java.util.stream.LongPipeline.sum(LongPipeline.java:405) at java.util.stream.ReferencePipeline.count(ReferencePipeline.java:526) at OOM.firstNPrimes(OOM.java:24) at OOM.main(OOM.java:11) -Aleksey. From aleksey.shipilev at oracle.com Tue Jun 4 07:51:18 2013 From: aleksey.shipilev at oracle.com (Aleksey Shipilev) Date: Tue, 04 Jun 2013 18:51:18 +0400 Subject: Build failure: langtools, cannot find symbol Objects.requireNonNull Message-ID: <51ADFEE6.6030902@oracle.com> Hi there, Building today's lambda/lambda fails even after a few clean rebuilds: ## Starting langtools Compiling 2 files for BUILD_TOOLS Compiling 25 properties into resource bundles Compiling 752 files for BUILD_BOOTSTRAP_LANGTOOLS Creating langtools/dist/bootstrap/lib/javac.jar Updating langtools/dist/lib/src.zip Compiling 755 files for BUILD_FULL_JAVAC /home/shade/trunks/lambda/build/linux-x86_64-normal-server-fastdebug/langtools/genstubs/java/util/Objects.java:3: error: package java.util.function does not exist import java.util.function.Supplier; ^ /home/shade/trunks/lambda/build/linux-x86_64-normal-server-fastdebug/langtools/genstubs/java/util/Objects.java:33: error: cannot find symbol public static native T requireNonNull(T obj, Supplier messageSupplier); ^ symbol: class Supplier location: class Objects 2 errors make[1]: *** [/home/shade/trunks/lambda/build/linux-x86_64-normal-server-fastdebug/langtools/classes/_the.batch] Error 1 make: *** [langtools-only] Error 2 Is this something known? -Aleksey. From paul.sandoz at oracle.com Tue Jun 4 08:09:05 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Tue, 4 Jun 2013 17:09:05 +0200 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: <51ADFDBA.30405@oracle.com> References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> <51ADFDBA.30405@oracle.com> Message-ID: On Jun 4, 2013, at 4:46 PM, Aleksey Shipilev wrote: > On 06/04/2013 06:17 PM, Paul Sandoz wrote: >> If i run using interpretive mode -Xint, it works fine, suggesting we >> are running into a hotspot issue, perhaps a hotspot/GC issue: > > I had reproduced this as well, and seeing > java.util.stream.SliceOps$SliceTask -> > java.util.Spliterators$LongArraySpliterator -> > long[] > > ...occupying the most of the heap (3 Gb on my machine). It passes with > -Xmx7g without problems. With lower heaps, it does a series of full GC, > which end up with: > > [Full GC (Ergonomics) [PSYoungGen: 557248K->555317K(901760K)] > [ParOldGen: 4190056K->4190056K(4194304K)] 4747304K->4745374K(5096064K), > [Metaspace: 4142K->4702K(110592K)], 0.0800150 secs] [Times: user=0.19 > sys=0.00, real=0.08 secs] > [Full GC (Ergonomics) [PSYoungGen: 557248K->0K(901760K)] [ParOldGen: > 4190056K->20912K(1710848K)] 4747304K->20912K(2612608K), [Metaspace: > 4144K->4702K(110592K)], 0.2308390 secs] [Times: user=0.15 sys=0.16, > real=0.23 secs] > > ...so the heap appears to be empty. The application is still munching > through data in the main thread, which explains why there is no > parallelism happening: > Ah! A light bulb just turned on :-) That stack trace is an artifact of the spliterator from iterator returning null due to it trapping an OOME and then the leaf processing kicks in the for the right hand side and the iterator is infinite. So it is a nasty secondary cause due to memory issues. Usually what would happen is the task would get cancelled. My conclusion is that those iterator form spliterators should never throw OOME. Still it does not explain why OOMEs are so happening for what seem like reasonable heap sizes (especially when interpreted mode works OK). Paul. > "main" #1 prio=5 os_prio=0 tid=0x00007fa290009800 nid=0x7342 runnable > [0x00007fa298ed1000] > java.lang.Thread.State: RUNNABLE > at java.util.stream.Nodes$SpinedNodeBuilder.accept(Nodes.java:1248) > at > java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:176) > at java.util.stream.LongPipeline$3$1.accept(LongPipeline.java:230) > at > java.util.PrimitiveIterator$OfLong.forEachRemaining(PrimitiveIterator.java:166) > at java.util.stream.LongStream$1.forEachRemaining(LongStream.java) > at > java.util.Spliterators$LongIteratorSpliterator.forEachRemaining(Spliterators.java:2029) > at java.util.Spliterator$OfLong.forEachRemaining(Spliterator.java:744) > at > java.util.Spliterators$LongIteratorSpliterator.forEachRemaining(Spliterators.java) > at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482) > at > java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472) > at java.util.stream.SliceOps$SliceTask.doLeaf(SliceOps.java:606) > at java.util.stream.SliceOps$SliceTask.doLeaf(SliceOps.java:553) > at java.util.stream.AbstractTask.compute(AbstractTask.java:312) > at java.util.concurrent.CountedCompleter.exec(CountedCompleter.java:710) > at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289) > at java.util.concurrent.ForkJoinTask.doInvoke(ForkJoinTask.java:385) > at java.util.concurrent.ForkJoinTask.invoke(ForkJoinTask.java:717) > at java.util.stream.SliceOps$1.opEvaluateParallelLazy(SliceOps.java:150) > at > java.util.stream.AbstractPipeline.sourceSpliterator(AbstractPipeline.java:442) > at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:230) > at java.util.stream.LongPipeline.reduce(LongPipeline.java:447) > at java.util.stream.LongPipeline.sum(LongPipeline.java:405) > at java.util.stream.ReferencePipeline.count(ReferencePipeline.java:526) > at OOM.firstNPrimes(OOM.java:24) > at OOM.main(OOM.java:11) > > > -Aleksey. From paul.sandoz at oracle.com Tue Jun 4 08:13:02 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Tue, 4 Jun 2013 17:13:02 +0200 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> <51ADFDBA.30405@oracle.com> Message-ID: <3C64EB59-C720-4B3B-95C0-4DE6EA2628EC@oracle.com> On Jun 4, 2013, at 5:09 PM, Paul Sandoz wrote: > On Jun 4, 2013, at 4:46 PM, Aleksey Shipilev wrote: > >> On 06/04/2013 06:17 PM, Paul Sandoz wrote: >>> If i run using interpretive mode -Xint, it works fine, suggesting we >>> are running into a hotspot issue, perhaps a hotspot/GC issue: >> >> I had reproduced this as well, and seeing >> java.util.stream.SliceOps$SliceTask -> >> java.util.Spliterators$LongArraySpliterator -> >> long[] >> >> ...occupying the most of the heap (3 Gb on my machine). It passes with >> -Xmx7g without problems. With lower heaps, it does a series of full GC, >> which end up with: >> >> [Full GC (Ergonomics) [PSYoungGen: 557248K->555317K(901760K)] >> [ParOldGen: 4190056K->4190056K(4194304K)] 4747304K->4745374K(5096064K), >> [Metaspace: 4142K->4702K(110592K)], 0.0800150 secs] [Times: user=0.19 >> sys=0.00, real=0.08 secs] >> [Full GC (Ergonomics) [PSYoungGen: 557248K->0K(901760K)] [ParOldGen: >> 4190056K->20912K(1710848K)] 4747304K->20912K(2612608K), [Metaspace: >> 4144K->4702K(110592K)], 0.2308390 secs] [Times: user=0.15 sys=0.16, >> real=0.23 secs] >> >> ...so the heap appears to be empty. The application is still munching >> through data in the main thread, which explains why there is no >> parallelism happening: >> > > Ah! A light bulb just turned on :-) > > That stack trace is an artifact of the spliterator from iterator returning null due to it trapping an OOME and then the leaf processing kicks in the for the right hand side and the iterator is infinite. So it is a nasty secondary cause due to memory issues. Usually what would happen is the task would get cancelled. > > My conclusion is that those iterator form spliterators should never throw OOME. > I meant to say "should never catch OOME and return null" Object[] a; try { a = new Object[n]; } catch (OutOfMemoryError oome) { return null; } Paul. > Still it does not explain why OOMEs are so happening for what seem like reasonable heap sizes (especially when interpreted mode works OK). > > Paul. > > >> "main" #1 prio=5 os_prio=0 tid=0x00007fa290009800 nid=0x7342 runnable >> [0x00007fa298ed1000] >> java.lang.Thread.State: RUNNABLE >> at java.util.stream.Nodes$SpinedNodeBuilder.accept(Nodes.java:1248) >> at >> java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:176) >> at java.util.stream.LongPipeline$3$1.accept(LongPipeline.java:230) >> at >> java.util.PrimitiveIterator$OfLong.forEachRemaining(PrimitiveIterator.java:166) >> at java.util.stream.LongStream$1.forEachRemaining(LongStream.java) >> at >> java.util.Spliterators$LongIteratorSpliterator.forEachRemaining(Spliterators.java:2029) >> at java.util.Spliterator$OfLong.forEachRemaining(Spliterator.java:744) >> at >> java.util.Spliterators$LongIteratorSpliterator.forEachRemaining(Spliterators.java) >> at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482) >> at >> java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472) >> at java.util.stream.SliceOps$SliceTask.doLeaf(SliceOps.java:606) >> at java.util.stream.SliceOps$SliceTask.doLeaf(SliceOps.java:553) >> at java.util.stream.AbstractTask.compute(AbstractTask.java:312) >> at java.util.concurrent.CountedCompleter.exec(CountedCompleter.java:710) >> at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289) >> at java.util.concurrent.ForkJoinTask.doInvoke(ForkJoinTask.java:385) >> at java.util.concurrent.ForkJoinTask.invoke(ForkJoinTask.java:717) >> at java.util.stream.SliceOps$1.opEvaluateParallelLazy(SliceOps.java:150) >> at >> java.util.stream.AbstractPipeline.sourceSpliterator(AbstractPipeline.java:442) >> at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:230) >> at java.util.stream.LongPipeline.reduce(LongPipeline.java:447) >> at java.util.stream.LongPipeline.sum(LongPipeline.java:405) >> at java.util.stream.ReferencePipeline.count(ReferencePipeline.java:526) >> at OOM.firstNPrimes(OOM.java:24) >> at OOM.main(OOM.java:11) >> >> >> -Aleksey. > From scolebourne at joda.org Tue Jun 4 08:13:36 2013 From: scolebourne at joda.org (Stephen Colebourne) Date: Tue, 4 Jun 2013 16:13:36 +0100 Subject: Optional -> OptionalResult Message-ID: Optional is, and will continue to be, a key debating point for those arguing for more FP. The pressure to make it more powerful will continue, especially given similar named features in other languages. Meanwhile I continue to fear Map>> and the like. The generics type system in Java simply isn't good enough to be doing anything like that, even if it were remotely desirable. Where the class is useful is in the return position. As Brian says "I think where we've tried to land is: do things that encourage people to use Optional only in return position". However, the one thing that hasn't been done is to name it as such. Simply rename "Optional" to "OptionalResult", or just "Result" and many of the issues go away. Those from an FP background will clearly see it as something different (if related) and continue to be disappointed (Java isn't going to satisfy them no matter what). More importantly, Java developers will only use the class in the return type position, simply because of its name. Of course it doesn't prevent Map>>, but it makes it much less likely just because the name no longer makes sense. If it is used in that way, its probably because it really is a collection of earlier results. Finally, I'd note that if named Result/OptionalResult, I don't overly mind which set of methods are on it or that it is a box. So long as there is the ability to query it using a simple if statement. Stephen On 24 May 2013 21:15, Brian Goetz wrote: > Optional has obvious upsides and downsides. Some of the downsides are: > - It's a box. Boxing can be heavy. > - The more general-purpose value-wrapper classes you have, the more some > people fear an explosion of unreadable types like > Map>, List List>> in API signatures. > > I think where we've tried to land is: do things that encourage people to use > Optional only in return position. These methods make it more useful in > return position while not increasing the temptation to use it elsewhere any > more than we already have. Hence "mostly harmless". > > > On 5/24/2013 4:10 PM, Tim Peierls wrote: >> >> On Fri, May 24, 2013 at 3:20 PM, Brian Goetz > > wrote: >> >> Proposed spec for methods on Optional, which would have the obvious >> counterparts in Optional{Int,Long,Double}. >> >> These methods are known to be useful and seem mostly harmless now >> that other things have settled. (I don't think they greatly >> increase the moral hazard of Optional in general, and they do make >> it more expressive.) >> >> >> I'm in the curious (unique?) position of both desperately wanting >> Optional and desperately *not* wanting lots of additional methods like >> these. If the price of having Optional is the presence of these methods, >> I'll suck it up, but "mostly harmless" is not exactly a ringing >> endorsement. >> >> --tim From christian.mallwitz at Commerzbank.com Tue Jun 4 08:15:18 2013 From: christian.mallwitz at Commerzbank.com (Mallwitz, Christian) Date: Tue, 4 Jun 2013 17:15:18 +0200 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: First of all adding -Xint seems to make the problem to go away for me as well: using a parallel stream will not use much more heap than a serial stream _and_ there is a speed up When not using -Xint the output from the isPrime predicate is reporting that increasingly bigger n are tested way beyond the 4,000,000 from the serial stream case (GC output removed): 10.077: 131349505 74.073: 137916980 141.865: 144812829 214.485: 152053470 292.511: 159656143 ... ... ... During that time heap usage slowly creaps up until the heap is completely filled and an OOM occurs for me. Christian -----Original Message----- From: Paul Sandoz [mailto:paul.sandoz at oracle.com] Sent: Tuesday, June 04, 2013 3:17 PM To: Mallwitz, Christian Cc: 'lambda-dev at openjdk.java.net' Subject: Re: Regression (b92): OOM on filter/limit operation on unbound/parallel stream Hi Christian, I can reproduce your behaviour of your test programming taking ages to run, but i needed to increase mx to 2g. Initially i notice lots of GCs then it starts slowing down with the occasional "GC (Allocation Failure)". Something fishy is going on here, it is very slow with one core pegged at 100% and Visual VM is showing that the used heap is way less than the heap size. If i run using interpretive mode -Xint, it works fine, suggesting we are running into a hotspot issue, perhaps a hotspot/GC issue: $ java -Xint -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps OOM2 -XX:ClassMetaspaceSize=104857600 -XX:InitialHeapSize=134217728 -XX:MaxHeapSize=1073741824 -XX:+PrintCommandLineFlags -XX:+PrintGC -XX:+PrintGCTimeStamps -XX:+UseCompressedKlassPointers -XX:+UseCompressedOops -XX:+UseParallelGC 3.766: [GC (Allocation Failure) 32767K->656K(125632K), 0.0010730 secs] 8.476: [GC (Allocation Failure) 33424K->592K(125632K), 0.0008800 secs] 13.520: 3999970 firstNPrimes ( 283146, false): 283146 13.623: [GC (Allocation Failure) 33360K->960K(125632K), 0.0010140 secs] 14.019: [GC (Allocation Failure) 33728K->6244K(125632K), 0.0035470 secs] 14.530: [GC (Allocation Failure) 39004K->11608K(124864K), 0.0050110 secs] 15.034: [GC (Allocation Failure) 43608K->23289K(123776K), 0.0071630 secs] 15.499: [GC (Allocation Failure) 48175K->27989K(129600K), 0.0033540 secs] 15.946: [GC (Allocation Failure) 53141K->38138K(126336K), 0.0083030 secs] 15.878: 4199968 16.043: 4475905 16.416: [GC (Allocation Failure) 57018K->24262K(111040K), 0.0027570 secs] firstNPrimes ( 283146, true): 283146 >From the GC output it looks like an ~ speed up of about 3-4x. I can even run with a lower mx value. Interestingly if i lower mx to say 32m i start running into similar issues. I have noticed GC output continually outputting a full GC. -- Because iterator is an ordered and infinite source then hooking it up to limit will always requiring buffering when going parallel. We have managed to reduce some of the internal memory churn but this really comes down to better documentation. To obtain 283_146 primes at least 3_999_971 elements will need to be buffered. The LongStream.iterate method extracts parallelism by sequentially copying a prefix of elements into an array and growing the array over time. Each array will be operated on by an F/J task. To get any parallel speed up the cost of processing elements must be higher than copying those elements into an array; i think primes is a good example of where this should work well. Note that a limit up to N does not guarantee that up to N elements will be processed upstream, it may be more, specially so given the array sizes increasing of iterate. Using boxed values is definitely gonna kill performance since it will mess up the caches, while the array of Long[] is OK the actually long values could be anywhere in memory. Paul. On Jun 4, 2013, at 2:02 PM, "Mallwitz, Christian" wrote: > Hi, > > Re-reporting problem for build 92: the filter/limit on unbound, parallel stream operation behaves very weird. How weird? Well: > > - the serial version uses about 16M of heap, the parallel gobbles up all of the 1GB defined as max > - it throws an OOM after running for hours while it is __NOT__ garbage collecting much but > - the filter predicate is called on millions of elements more than what can be observed using a serial stream > - I can't observe any parallelism (based on number of cores and system load - 4 cores and only 25% load) > > I'm using 1.8.0-ea-lambda-nightly-h4544-20130526-b92-b00 on a Windows XP 32 bit machine - VM args: -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps > > My test program tries to find the first 283,146 prime numbers (which are all below 4,000,000). It executes the filter/limit operation on a serial stream first and prints out numbers tested for primality occasionally. > > Thanks > Christian > > > > > > package com.snuffbumble.lambda; > > import java.util.stream.LongStream; > import java.util.stream.Stream; > > public class OOM { > > public static void main(String... ignored) { > > // first 283_146 primes are all < 4_000_000 > > firstNPrimes(283_146, getIteratorBasedStream(false)); // only minor GC - max heap 16M > firstNPrimes(283_146, getIteratorBasedStream(true)); // full GC - up to max heap 1GB and subsequent OOM > } > > private static Stream getIteratorBasedStream(boolean produceParallelStream) { > Stream s = LongStream.iterate(1L, n -> n + 1L).boxed(); > return produceParallelStream ? s.parallel() : s; > } > > private static void firstNPrimes(int n, Stream stream) { > System.out.println(String.format("firstNPrimes (%8d, %5b): %8d", n, stream.isParallel(), > stream > .filter(OOM::isPrime) > .limit(n) // limit after primality test > .count())); > } > > private static long start_millis = System.currentTimeMillis(); > private static long max_n_seen = 3_999_970L; > > private static boolean isPrime(long n) { > > if (n >= max_n_seen) { > System.out.println(String.format("%.3f: %d", (System.currentTimeMillis() - start_millis)/1000.0, n)); > max_n_seen = n + (n/20L); // new max_n_seen 5% larger than current n > } > > if (n <= 1) { return false; } > if (n == 2) { return true; } > if (n % 2 == 0) { return false; } > for (int i = 3; i <= (int) Math.sqrt(n); i += 2) { if (n % i == 0) return false; } > return true; > } > } > > From zhong.j.yu at gmail.com Tue Jun 4 09:16:00 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Tue, 4 Jun 2013 11:16:00 -0500 Subject: Forget Optional, adopt Try? In-Reply-To: References: Message-ID: On Tue, Jun 4, 2013 at 2:52 AM, Jed Wesley-Smith wrote: > Actually Try is a (sort of*) monad on exception handling. It is really an > Either (or disjunction) class that is specialised to catch exceptions during > map/flatMap. > > As you point out, Option is isomorphic to an Either with no useful value on > the left hand side (Unit or Void for instance), and a true Either can return > something meaningful as to the reason why there was nothing. > > Making something that was returning @Nullable T an Optional simply says > to the client, "there may not be a return value here". Making it return an > Either says to the client "there may not be a return value here and X > is why". This is actually not necessary in many cases. Imagine a > Map.getOptional, there is no real reason to supply > BecauseThisMapDidntContainValue on the left hand side if the key isn't > found? it is somewhat obvious. Even though the failure is obvious, what's the harm of returning it anyway? It'll require extra work for API authors, but it doesn't affect API users at all. The failure object might become useful later where we need to take different actions based on different types of failures occurred earlier. Returning a vacuous state to imply the failure only works in the immediate vicinity of the callsite. (By failure I don't mean "error". Failure should be a checked exception, it is a "normal" result of the action) Though we can have both Option and Try, I don't see the reason to keep Option while Try covers all use cases of Option. And finally I propose to rename "Try" to "Result". A Result is either a success with a value of type T, or a failure with an Exception. Zhong Yu > > So, while Either and Option to serve similar purposes, there are important > differences. Rather than choose one, you really want to have both in the > kit. > > cheers, > jed. > > * it is sort of a monad as a monad should really obey the contravariant > functor laws, and it doesn't due to the fact that composition is violated: > https://issues.scala-lang.org/browse/SI-6284 > > > On 4 June 2013 14:21, Zhong Yu wrote: >> >> I'm thinking that if we have something like scala's Try, it'll >> express APIs' intentions better than Optional. >> >> Some people view Optional as a collection of either 0 or 1 element. >> That doesn't seem to be what an API author wants to express by >> returning an Optional. The actual intention is that, either the action >> succeeds with a value (not a collection of!), or it fails (with an >> unspecified or implied reason). Try describes that intention >> precisely (but it probably needs a better name) >> >> Suppose we have a good old method that returns a nullable >> >> /** return null if there's no element */ >> T getFirst(); >> >> Why do we hate it? Probably because we need to insert null handling in >> the code path >> >> T first = getFirst(); >> if(first==null) >> blah blah >> first.doSomething()... >> >> we would rather defer null handling to some later time, leaving the >> main code path cleaner. Java already has a way to do that - exception >> propagation. For example the method can be designed to throw >> >> T getFirst() throw NotFoundExcpetion; >> // for efficiency, throw a cached immutable exception object >> >> T first = getFirst(); // may throw - exception will be handled >> somewhere else >> // no null handling here >> first.doSomething() >> >> But lots of try-catch blocks may make code look ugly. Try may be nicer >> >> /** fail with NotFoundException if there's no element */ >> Try getFirst(); >> >> Try first = getFirst(); >> first.map().filter().recover().... >> >> So we don't need Optional. Try does the same thing, and expresses >> the intention better. And Try has broader use cases. It'll also >> appease those who prefer returning errors over throwing errors. >> >> Sounds good? >> >> Zhong Yu >> > From maurizio.cimadamore at oracle.com Tue Jun 4 09:18:27 2013 From: maurizio.cimadamore at oracle.com (Maurizio Cimadamore) Date: Tue, 04 Jun 2013 17:18:27 +0100 Subject: Build failure: langtools, cannot find symbol Objects.requireNonNull In-Reply-To: <51ADFEE6.6030902@oracle.com> References: <51ADFEE6.6030902@oracle.com> Message-ID: <51AE1353.5090902@oracle.com> This is typically caused by having JDK 8 as your boot JDK. Try use JDK 7 and see if that solves your issue. Maurizio On 04/06/13 15:51, Aleksey Shipilev wrote: > Hi there, > > Building today's lambda/lambda fails even after a few clean rebuilds: > > ## Starting langtools > Compiling 2 files for BUILD_TOOLS > Compiling 25 properties into resource bundles > Compiling 752 files for BUILD_BOOTSTRAP_LANGTOOLS > Creating langtools/dist/bootstrap/lib/javac.jar > Updating langtools/dist/lib/src.zip > Compiling 755 files for BUILD_FULL_JAVAC > /home/shade/trunks/lambda/build/linux-x86_64-normal-server-fastdebug/langtools/genstubs/java/util/Objects.java:3: > error: package java.util.function does not exist > import java.util.function.Supplier; > ^ > /home/shade/trunks/lambda/build/linux-x86_64-normal-server-fastdebug/langtools/genstubs/java/util/Objects.java:33: > error: cannot find symbol > public static native T requireNonNull(T obj, Supplier > messageSupplier); > ^ > symbol: class Supplier > location: class Objects > 2 errors > make[1]: *** > [/home/shade/trunks/lambda/build/linux-x86_64-normal-server-fastdebug/langtools/classes/_the.batch] > Error 1 > make: *** [langtools-only] Error 2 > > Is this something known? > > -Aleksey. > From zhong.j.yu at gmail.com Tue Jun 4 09:36:04 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Tue, 4 Jun 2013 11:36:04 -0500 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: I like Result. I think it should be able to carry an Exception too. API authors who don't care to give an exception use the default exception. interface Result // return a failure with a NoResultException public static Result none(){ return NONE; } On Tue, Jun 4, 2013 at 10:13 AM, Stephen Colebourne wrote: > Optional is, and will continue to be, a key debating point for those > arguing for more FP. The pressure to make it more powerful will > continue, especially given similar named features in other languages. > > Meanwhile I continue to fear Map>> and > the like. The generics type system in Java simply isn't good enough to > be doing anything like that, even if it were remotely desirable. > > Where the class is useful is in the return position. As Brian says "I > think where we've tried to land is: do things that encourage people to > use Optional only in return position". > > However, the one thing that hasn't been done is to name it as such. > Simply rename "Optional" to "OptionalResult", or just "Result" and > many of the issues go away. Those from an FP background will clearly > see it as something different (if related) and continue to be > disappointed (Java isn't going to satisfy them no matter what). More > importantly, Java developers will only use the class in the return > type position, simply because of its name. > > Of course it doesn't prevent Map>>, but it > makes it much less likely just because the name no longer makes sense. > If it is used in that way, its probably because it really is a > collection of earlier results. > > Finally, I'd note that if named Result/OptionalResult, I don't overly > mind which set of methods are on it or that it is a box. So long as > there is the ability to query it using a simple if statement. > > Stephen > > > > On 24 May 2013 21:15, Brian Goetz wrote: >> Optional has obvious upsides and downsides. Some of the downsides are: >> - It's a box. Boxing can be heavy. >> - The more general-purpose value-wrapper classes you have, the more some >> people fear an explosion of unreadable types like >> Map>, List> List>> in API signatures. >> >> I think where we've tried to land is: do things that encourage people to use >> Optional only in return position. These methods make it more useful in >> return position while not increasing the temptation to use it elsewhere any >> more than we already have. Hence "mostly harmless". >> >> >> On 5/24/2013 4:10 PM, Tim Peierls wrote: >>> >>> On Fri, May 24, 2013 at 3:20 PM, Brian Goetz >> > wrote: >>> >>> Proposed spec for methods on Optional, which would have the obvious >>> counterparts in Optional{Int,Long,Double}. >>> >>> These methods are known to be useful and seem mostly harmless now >>> that other things have settled. (I don't think they greatly >>> increase the moral hazard of Optional in general, and they do make >>> it more expressive.) >>> >>> >>> I'm in the curious (unique?) position of both desperately wanting >>> Optional and desperately *not* wanting lots of additional methods like >>> these. If the price of having Optional is the presence of these methods, >>> I'll suck it up, but "mostly harmless" is not exactly a ringing >>> endorsement. >>> >>> --tim > From paul.sandoz at oracle.com Tue Jun 4 09:36:31 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Tue, 04 Jun 2013 16:36:31 +0000 Subject: hg: lambda/lambda/jdk: Clean up to range test. Message-ID: <20130604163708.D2F6248F31@hg.openjdk.java.net> Changeset: d47b5bd9b574 Author: psandoz Date: 2013-06-04 18:35 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/d47b5bd9b574 Clean up to range test. ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java From paul.sandoz at oracle.com Tue Jun 4 12:03:13 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Tue, 4 Jun 2013 21:03:13 +0200 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: Digging more into the problem... of course i made the fatal/silly mistake of prematurely blaming hotspot/gc :-) In addition to the catching of the OOME the other problem is the main task creation loop is too aggressive creating tasks for a spliterator from iterator. Tasks are created faster than they can be processed and this gets worse as the numbers get larger since it takes more time to check if a number is a prime number. Normally this is ok as spliterators are light-weight, but the spliterator from iterator copies stuff into an array of increasing size. In such a case we need that main task loop to take part in processing other tasks. Ideally we would know the tree-shape produced by a spliterator but failing that we can do something in the slice op task. I am also pondering getting rid of the slice op task all-together and replacing with a special skip/limit spliterator using the same techniques as the spliterator from iterator, there by side-stepping the problem. Paul. On Jun 4, 2013, at 5:15 PM, "Mallwitz, Christian" wrote: > First of all adding -Xint seems to make the problem to go away for me as well: using a parallel stream will not use much more heap than a serial stream _and_ there is a speed up > > When not using -Xint the output from the isPrime predicate is reporting that increasingly bigger n are tested way beyond the 4,000,000 from the serial stream case (GC output removed): > > 10.077: 131349505 > 74.073: 137916980 > 141.865: 144812829 > 214.485: 152053470 > 292.511: 159656143 > ... > ... > ... > > During that time heap usage slowly creaps up until the heap is completely filled and an OOM occurs for me. > > Christian > > -----Original Message----- > From: Paul Sandoz [mailto:paul.sandoz at oracle.com] > Sent: Tuesday, June 04, 2013 3:17 PM > To: Mallwitz, Christian > Cc: 'lambda-dev at openjdk.java.net' > Subject: Re: Regression (b92): OOM on filter/limit operation on unbound/parallel stream > > Hi Christian, > > I can reproduce your behaviour of your test programming taking ages to run, but i needed to increase mx to 2g. Initially i notice lots of GCs then it starts slowing down with the occasional "GC (Allocation Failure)". Something fishy is going on here, it is very slow with one core pegged at 100% and Visual VM is showing that the used heap is way less than the heap size. > > If i run using interpretive mode -Xint, it works fine, suggesting we are running into a hotspot issue, perhaps a hotspot/GC issue: > > $ java -Xint -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps OOM2 > -XX:ClassMetaspaceSize=104857600 -XX:InitialHeapSize=134217728 -XX:MaxHeapSize=1073741824 -XX:+PrintCommandLineFlags -XX:+PrintGC -XX:+PrintGCTimeStamps -XX:+UseCompressedKlassPointers -XX:+UseCompressedOops -XX:+UseParallelGC > 3.766: [GC (Allocation Failure) 32767K->656K(125632K), 0.0010730 secs] > 8.476: [GC (Allocation Failure) 33424K->592K(125632K), 0.0008800 secs] > 13.520: 3999970 > firstNPrimes ( 283146, false): 283146 > 13.623: [GC (Allocation Failure) 33360K->960K(125632K), 0.0010140 secs] > 14.019: [GC (Allocation Failure) 33728K->6244K(125632K), 0.0035470 secs] > 14.530: [GC (Allocation Failure) 39004K->11608K(124864K), 0.0050110 secs] > 15.034: [GC (Allocation Failure) 43608K->23289K(123776K), 0.0071630 secs] > 15.499: [GC (Allocation Failure) 48175K->27989K(129600K), 0.0033540 secs] > 15.946: [GC (Allocation Failure) 53141K->38138K(126336K), 0.0083030 secs] > 15.878: 4199968 > 16.043: 4475905 > 16.416: [GC (Allocation Failure) 57018K->24262K(111040K), 0.0027570 secs] > firstNPrimes ( 283146, true): 283146 > > >> From the GC output it looks like an ~ speed up of about 3-4x. > > I can even run with a lower mx value. Interestingly if i lower mx to say 32m i start running into similar issues. I have noticed GC output continually outputting a full GC. > > -- > > Because iterator is an ordered and infinite source then hooking it up to limit will always requiring buffering when going parallel. We have managed to reduce some of the internal memory churn but this really comes down to better documentation. > > To obtain 283_146 primes at least 3_999_971 elements will need to be buffered. The LongStream.iterate method extracts parallelism by sequentially copying a prefix of elements into an array and growing the array over time. Each array will be operated on by an F/J task. To get any parallel speed up the cost of processing elements must be higher than copying those elements into an array; i think primes is a good example of where this should work well. > > Note that a limit up to N does not guarantee that up to N elements will be processed upstream, it may be more, specially so given the array sizes increasing of iterate. > > Using boxed values is definitely gonna kill performance since it will mess up the caches, while the array of Long[] is OK the actually long values could be anywhere in memory. > > Paul. > > On Jun 4, 2013, at 2:02 PM, "Mallwitz, Christian" wrote: > >> Hi, >> >> Re-reporting problem for build 92: the filter/limit on unbound, parallel stream operation behaves very weird. How weird? Well: >> >> - the serial version uses about 16M of heap, the parallel gobbles up all of the 1GB defined as max >> - it throws an OOM after running for hours while it is __NOT__ garbage collecting much but >> - the filter predicate is called on millions of elements more than what can be observed using a serial stream > >> - I can't observe any parallelism (based on number of cores and system load - 4 cores and only 25% load) >> >> I'm using 1.8.0-ea-lambda-nightly-h4544-20130526-b92-b00 on a Windows XP 32 bit machine - VM args: -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps >> >> My test program tries to find the first 283,146 prime numbers (which are all below 4,000,000). It executes the filter/limit operation on a serial stream first and prints out numbers tested for primality occasionally. >> >> Thanks >> Christian >> >> >> >> >> >> package com.snuffbumble.lambda; >> >> import java.util.stream.LongStream; >> import java.util.stream.Stream; >> >> public class OOM { >> >> public static void main(String... ignored) { >> >> // first 283_146 primes are all < 4_000_000 >> >> firstNPrimes(283_146, getIteratorBasedStream(false)); // only minor GC - max heap 16M >> firstNPrimes(283_146, getIteratorBasedStream(true)); // full GC - up to max heap 1GB and subsequent OOM >> } >> >> private static Stream getIteratorBasedStream(boolean produceParallelStream) { >> Stream s = LongStream.iterate(1L, n -> n + 1L).boxed(); >> return produceParallelStream ? s.parallel() : s; >> } >> >> private static void firstNPrimes(int n, Stream stream) { >> System.out.println(String.format("firstNPrimes (%8d, %5b): %8d", n, stream.isParallel(), >> stream >> .filter(OOM::isPrime) >> .limit(n) // limit after primality test >> .count())); >> } >> >> private static long start_millis = System.currentTimeMillis(); >> private static long max_n_seen = 3_999_970L; >> >> private static boolean isPrime(long n) { >> >> if (n >= max_n_seen) { >> System.out.println(String.format("%.3f: %d", (System.currentTimeMillis() - start_millis)/1000.0, n)); >> max_n_seen = n + (n/20L); // new max_n_seen 5% larger than current n >> } >> >> if (n <= 1) { return false; } >> if (n == 2) { return true; } >> if (n % 2 == 0) { return false; } >> for (int i = 3; i <= (int) Math.sqrt(n); i += 2) { if (n % i == 0) return false; } >> return true; >> } >> } >> >> > > From claytonwohl at gmail.com Tue Jun 4 13:36:41 2013 From: claytonwohl at gmail.com (Clayton Wohl) Date: Tue, 4 Jun 2013 15:36:41 -0500 Subject: Optional -> OptionalResult Message-ID: Why would "Map>>" be more of a concern than any other ridiculous combination of generics nesting? How about List>>>>? Usually, devs don't nest optionals inside of lists/maps. I'm sure it will happen in some edge case, but in the Scala code or the Functional Java code bases I've worked in, people do not do that, just like they don't do lots of other crazy combinations of generics that are technically possible in Java 5+. For the name, I like Option/Optional, however, that's a relatively minor detail and I will be happy with whatever the JDK team chooses. Stephen, the reasoning for an Optional type with map/flatMap/forEach functionality is very convincing and I don't believe it's appeal is limited to elite FP experts, which I am definitely not. I've seen lots of junior Java devs appreciate the same functionality in Functional Java. Your opposition to this does not seem to have a grounding in reason. BTW, the new date/time library you've worked on looks amazing. I've been using the plug-in version in my personal projects for years, and I am excited to see it broadly adopted into the core JDK 8. On Tue, Jun 4, 2013 at 10:13 AM, Stephen Colebourne wrote: > Optional is, and will continue to be, a key debating point for those > arguing for more FP. The pressure to make it more powerful will > continue, especially given similar named features in other languages. > > Meanwhile I continue to fear Map>> and > the like. The generics type system in Java simply isn't good enough to > be doing anything like that, even if it were remotely desirable. From zhong.j.yu at gmail.com Tue Jun 4 14:26:06 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Tue, 4 Jun 2013 16:26:06 -0500 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: "Option" sounds like the producer has a choice, it can choose to produce something or nothing based on some private/undisclosed reasons. That connotation may mislead people into using it for the wrong reasons, e.g. as input type. On Tue, Jun 4, 2013 at 3:36 PM, Clayton Wohl wrote: > Why would "Map>>" be more of a concern than > any other ridiculous combination of generics nesting? How about > List>>>>? > > Usually, devs don't nest optionals inside of lists/maps. I'm sure it will > happen in some edge case, but in the Scala code or the Functional Java code > bases I've worked in, people do not do that, just like they don't do lots > of other crazy combinations of generics that are technically possible in > Java 5+. > > For the name, I like Option/Optional, however, that's a relatively minor > detail and I will be happy with whatever the JDK team chooses. > > Stephen, the reasoning for an Optional type with map/flatMap/forEach > functionality is very convincing and I don't believe it's appeal is limited > to elite FP experts, which I am definitely not. I've seen lots of junior > Java devs appreciate the same functionality in Functional Java. Your > opposition to this does not seem to have a grounding in reason. > > BTW, the new date/time library you've worked on looks amazing. I've been > using the plug-in version in my personal projects for years, and I am > excited to see it broadly adopted into the core JDK 8. > > > On Tue, Jun 4, 2013 at 10:13 AM, Stephen Colebourne > wrote: >> Optional is, and will continue to be, a key debating point for those >> arguing for more FP. The pressure to make it more powerful will >> continue, especially given similar named features in other languages. >> >> Meanwhile I continue to fear Map>> and >> the like. The generics type system in Java simply isn't good enough to >> be doing anything like that, even if it were remotely desirable. > From john.r.rose at oracle.com Tue Jun 4 14:36:32 2013 From: john.r.rose at oracle.com (John Rose) Date: Tue, 4 Jun 2013 14:36:32 -0700 Subject: Comparator/Comparators API change proposal In-Reply-To: <51AD0BA8.1050007@oracle.com> References: <51AD0BA8.1050007@oracle.com> Message-ID: <24AE64DB-7C38-43E1-AE73-EEA0E4976550@oracle.com> On Jun 3, 2013, at 2:33 PM, Henry Jen wrote: > 2. Rename various comparing methods to comparing, comparingInt, > comparingLong and comparingDouble accordingly. This seems like a code smell. Let me see if I understand the issue: When users sort with primitive-valued key extractors, they will have to add noise words "Int", etc., to their code to get the compiler to accept the code. These noise words exist only to get past a technical overloading difficulty, and do not capture logical details of interest to the user. Moreover, if users leave out the noise words, the code will still compile and work almost* the same (due to autoboxing). (*Because java.lang.Double comparison is a little different from double comparison.) E.g., comparing(String::length) == comparing( (Function) String::length ) == comparing( (String s)->s.length() ). This extra help to the compiler is needed because it doesn't know IntFunction is preferable to Function, when resolving overloadings. That is because IntFunction does not extend Function. Is that right? ? John From henry.jen at oracle.com Tue Jun 4 15:11:42 2013 From: henry.jen at oracle.com (Henry Jen) Date: Tue, 04 Jun 2013 15:11:42 -0700 Subject: Comparator/Comparators API change proposal In-Reply-To: <24AE64DB-7C38-43E1-AE73-EEA0E4976550@oracle.com> References: <51AD0BA8.1050007@oracle.com> <24AE64DB-7C38-43E1-AE73-EEA0E4976550@oracle.com> Message-ID: <51AE661E.30500@oracle.com> On 06/04/2013 02:36 PM, John Rose wrote: > On Jun 3, 2013, at 2:33 PM, Henry Jen > wrote: > > Moreover, if users leave out the noise words, the code will still > compile and work almost* the same (due to autoboxing). > True. > (*Because java.lang.Double comparison is a little different from double > comparison.) > > E.g., comparing(String::length) == comparing( (Function) > String::length ) == comparing( (String s)->s.length() ). > > This extra help to the compiler is needed because it doesn't know > IntFunction is preferable to Function, when resolving > overloadings. > > That is because IntFunction does not extend Function. > > Is that right? > Your understanding is correct, as the IntFunction to extend Function, I think this had been explored before? I didn't follow through the whole discussion to see why we didn't do that, perhaps something related to boxing... Cheers, Henry From jed at wesleysmith.io Tue Jun 4 15:31:34 2013 From: jed at wesleysmith.io (Jed Wesley-Smith) Date: Wed, 5 Jun 2013 08:31:34 +1000 Subject: Forget Optional, adopt Try? In-Reply-To: References: Message-ID: An Exception (or Throwable) on the left is really quite limiting. For instance with the case where you want an obvious failure, and you don't need to or want to produce a failure value, you'd simply want an Either (or just Option but I digress). For many other cases, you want to provide richer data-types such as collections of errors if a validation failed like Either>, A>. The Throwable type is only to be part of the throw/throws machinery, there is really no need to limit generally useful kit to it. cheers, jed. On 5 June 2013 02:16, Zhong Yu wrote: > On Tue, Jun 4, 2013 at 2:52 AM, Jed Wesley-Smith > wrote: > > Actually Try is a (sort of*) monad on exception handling. It is really an > > Either (or disjunction) class that is specialised to catch exceptions > during > > map/flatMap. > > > > As you point out, Option is isomorphic to an Either with no useful value > on > > the left hand side (Unit or Void for instance), and a true Either can > return > > something meaningful as to the reason why there was nothing. > > > > Making something that was returning @Nullable T an Optional simply > says > > to the client, "there may not be a return value here". Making it return > an > > Either says to the client "there may not be a return value here > and X > > is why". This is actually not necessary in many cases. Imagine a > > Map.getOptional, there is no real reason to supply > > BecauseThisMapDidntContainValue on the left hand side if the key isn't > > found? it is somewhat obvious. > > Even though the failure is obvious, what's the harm of returning it > anyway? It'll require extra work for API authors, but it doesn't > affect API users at all. The failure object might become useful later > where we need to take different actions based on different types of > failures occurred earlier. Returning a vacuous state to imply the > failure only works in the immediate vicinity of the callsite. > > (By failure I don't mean "error". Failure should be a checked > exception, it is a "normal" result of the action) > > Though we can have both Option and Try, I don't see the reason to keep > Option while Try covers all use cases of Option. > > And finally I propose to rename "Try" to "Result". A Result is > either a success with a value of type T, or a failure with an > Exception. > > Zhong Yu > > > > > So, while Either and Option to serve similar purposes, there are > important > > differences. Rather than choose one, you really want to have both in the > > kit. > > > > cheers, > > jed. > > > > * it is sort of a monad as a monad should really obey the contravariant > > functor laws, and it doesn't due to the fact that composition is > violated: > > https://issues.scala-lang.org/browse/SI-6284 > > > > > > On 4 June 2013 14:21, Zhong Yu wrote: > >> > >> I'm thinking that if we have something like scala's Try, it'll > >> express APIs' intentions better than Optional. > >> > >> Some people view Optional as a collection of either 0 or 1 element. > >> That doesn't seem to be what an API author wants to express by > >> returning an Optional. The actual intention is that, either the action > >> succeeds with a value (not a collection of!), or it fails (with an > >> unspecified or implied reason). Try describes that intention > >> precisely (but it probably needs a better name) > >> > >> Suppose we have a good old method that returns a nullable > >> > >> /** return null if there's no element */ > >> T getFirst(); > >> > >> Why do we hate it? Probably because we need to insert null handling in > >> the code path > >> > >> T first = getFirst(); > >> if(first==null) > >> blah blah > >> first.doSomething()... > >> > >> we would rather defer null handling to some later time, leaving the > >> main code path cleaner. Java already has a way to do that - exception > >> propagation. For example the method can be designed to throw > >> > >> T getFirst() throw NotFoundExcpetion; > >> // for efficiency, throw a cached immutable exception object > >> > >> T first = getFirst(); // may throw - exception will be handled > >> somewhere else > >> // no null handling here > >> first.doSomething() > >> > >> But lots of try-catch blocks may make code look ugly. Try may be > nicer > >> > >> /** fail with NotFoundException if there's no element */ > >> Try getFirst(); > >> > >> Try first = getFirst(); > >> first.map().filter().recover().... > >> > >> So we don't need Optional. Try does the same thing, and expresses > >> the intention better. And Try has broader use cases. It'll also > >> appease those who prefer returning errors over throwing errors. > >> > >> Sounds good? > >> > >> Zhong Yu > >> > > > From forax at univ-mlv.fr Tue Jun 4 15:32:05 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Wed, 05 Jun 2013 00:32:05 +0200 Subject: Comparator/Comparators API change proposal In-Reply-To: <24AE64DB-7C38-43E1-AE73-EEA0E4976550@oracle.com> References: <51AD0BA8.1050007@oracle.com> <24AE64DB-7C38-43E1-AE73-EEA0E4976550@oracle.com> Message-ID: <51AE6AE5.7060404@univ-mlv.fr> On 06/04/2013 11:36 PM, John Rose wrote: > On Jun 3, 2013, at 2:33 PM, Henry Jen wrote: > >> 2. Rename various comparing methods to comparing, comparingInt, >> comparingLong and comparingDouble accordingly. > This seems like a code smell. Let me see if I understand the issue: > > When users sort with primitive-valued key extractors, they will have to add noise words "Int", etc., to their code to get the compiler to accept the code. > > These noise words exist only to get past a technical overloading difficulty, and do not capture logical details of interest to the user. > > Moreover, if users leave out the noise words, the code will still compile and work almost* the same (due to autoboxing). > > (*Because java.lang.Double comparison is a little different from double comparison.) > > E.g., comparing(String::length) == comparing( (Function) String::length ) == comparing( (String s)->s.length() ). > > This extra help to the compiler is needed because it doesn't know IntFunction is preferable to Function, when resolving overloadings. > > That is because IntFunction does not extend Function. > > Is that right? or because in the inference mechanism, Integer is not recognized as the boxing of an int, or if you prefer T -> int is not a specialization of T -> Integer. > > ? John > R?mi From zhong.j.yu at gmail.com Tue Jun 4 16:13:36 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Tue, 4 Jun 2013 18:13:36 -0500 Subject: Forget Optional, adopt Try? In-Reply-To: References: Message-ID: Ideally each method can design its own return type that represents all possible outcomes in the best way, but that requires too much effort. A lot of methods just want to return T|Exception, so let's provide a T|Exception type for them. Why Exception though? I argue that Exception is a familiar type to programmers; it can be lightweight without stacktrace; it is typed and it can contain structured info; we may want to capture a thrown Exception and wrap it as a failure, or we may want to throw a failure as an Exception. Future/Promise use Throwable to represent action failure, if that works fine in real world, the same thing should work for immediate Result too. I would limit it to Exception though, not the more general Throwable. Option is more like T|null, and I say we can use T|NoResultException to replace it. Zhong Yu On Tue, Jun 4, 2013 at 5:31 PM, Jed Wesley-Smith wrote: > An Exception (or Throwable) on the left is really quite limiting. For > instance with the case where you want an obvious failure, and you don't need > to or want to produce a failure value, you'd simply want an Either > (or just Option but I digress). For many other cases, you want to provide > richer data-types such as collections of errors if a validation failed like > Either>, A>. > > The Throwable type is only to be part of the throw/throws machinery, there > is really no need to limit generally useful kit to it. > > cheers, > jed. > > > On 5 June 2013 02:16, Zhong Yu wrote: >> >> On Tue, Jun 4, 2013 at 2:52 AM, Jed Wesley-Smith >> wrote: >> > Actually Try is a (sort of*) monad on exception handling. It is really >> > an >> > Either (or disjunction) class that is specialised to catch exceptions >> > during >> > map/flatMap. >> > >> > As you point out, Option is isomorphic to an Either with no useful value >> > on >> > the left hand side (Unit or Void for instance), and a true Either can >> > return >> > something meaningful as to the reason why there was nothing. >> > >> > Making something that was returning @Nullable T an Optional simply >> > says >> > to the client, "there may not be a return value here". Making it return >> > an >> > Either says to the client "there may not be a return value here >> > and X >> > is why". This is actually not necessary in many cases. Imagine a >> > Map.getOptional, there is no real reason to supply >> > BecauseThisMapDidntContainValue on the left hand side if the key isn't >> > found? it is somewhat obvious. >> >> Even though the failure is obvious, what's the harm of returning it >> anyway? It'll require extra work for API authors, but it doesn't >> affect API users at all. The failure object might become useful later >> where we need to take different actions based on different types of >> failures occurred earlier. Returning a vacuous state to imply the >> failure only works in the immediate vicinity of the callsite. >> >> (By failure I don't mean "error". Failure should be a checked >> exception, it is a "normal" result of the action) >> >> Though we can have both Option and Try, I don't see the reason to keep >> Option while Try covers all use cases of Option. >> >> And finally I propose to rename "Try" to "Result". A Result is >> either a success with a value of type T, or a failure with an >> Exception. >> >> Zhong Yu >> >> > >> > So, while Either and Option to serve similar purposes, there are >> > important >> > differences. Rather than choose one, you really want to have both in the >> > kit. >> > >> > cheers, >> > jed. >> > >> > * it is sort of a monad as a monad should really obey the contravariant >> > functor laws, and it doesn't due to the fact that composition is >> > violated: >> > https://issues.scala-lang.org/browse/SI-6284 >> > >> > >> > On 4 June 2013 14:21, Zhong Yu wrote: >> >> >> >> I'm thinking that if we have something like scala's Try, it'll >> >> express APIs' intentions better than Optional. >> >> >> >> Some people view Optional as a collection of either 0 or 1 element. >> >> That doesn't seem to be what an API author wants to express by >> >> returning an Optional. The actual intention is that, either the action >> >> succeeds with a value (not a collection of!), or it fails (with an >> >> unspecified or implied reason). Try describes that intention >> >> precisely (but it probably needs a better name) >> >> >> >> Suppose we have a good old method that returns a nullable >> >> >> >> /** return null if there's no element */ >> >> T getFirst(); >> >> >> >> Why do we hate it? Probably because we need to insert null handling in >> >> the code path >> >> >> >> T first = getFirst(); >> >> if(first==null) >> >> blah blah >> >> first.doSomething()... >> >> >> >> we would rather defer null handling to some later time, leaving the >> >> main code path cleaner. Java already has a way to do that - exception >> >> propagation. For example the method can be designed to throw >> >> >> >> T getFirst() throw NotFoundExcpetion; >> >> // for efficiency, throw a cached immutable exception object >> >> >> >> T first = getFirst(); // may throw - exception will be handled >> >> somewhere else >> >> // no null handling here >> >> first.doSomething() >> >> >> >> But lots of try-catch blocks may make code look ugly. Try may be >> >> nicer >> >> >> >> /** fail with NotFoundException if there's no element */ >> >> Try getFirst(); >> >> >> >> Try first = getFirst(); >> >> first.map().filter().recover().... >> >> >> >> So we don't need Optional. Try does the same thing, and expresses >> >> the intention better. And Try has broader use cases. It'll also >> >> appease those who prefer returning errors over throwing errors. >> >> >> >> Sounds good? >> >> >> >> Zhong Yu >> >> >> > > > From forax at univ-mlv.fr Tue Jun 4 16:25:15 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Wed, 05 Jun 2013 01:25:15 +0200 Subject: Comparator/Comparators API change proposal In-Reply-To: <51AE6AE5.7060404@univ-mlv.fr> References: <51AD0BA8.1050007@oracle.com> <24AE64DB-7C38-43E1-AE73-EEA0E4976550@oracle.com> <51AE6AE5.7060404@univ-mlv.fr> Message-ID: <51AE775B.5090007@univ-mlv.fr> On 06/05/2013 12:32 AM, Remi Forax wrote: > On 06/04/2013 11:36 PM, John Rose wrote: >> On Jun 3, 2013, at 2:33 PM, Henry Jen wrote: >> >>> 2. Rename various comparing methods to comparing, comparingInt, >>> comparingLong and comparingDouble accordingly. >> This seems like a code smell. Let me see if I understand the issue: >> >> When users sort with primitive-valued key extractors, they will have to add noise words "Int", etc., to their code to get the compiler to accept the code. >> >> These noise words exist only to get past a technical overloading difficulty, and do not capture logical details of interest to the user. >> >> Moreover, if users leave out the noise words, the code will still compile and work almost* the same (due to autoboxing). >> >> (*Because java.lang.Double comparison is a little different from double comparison.) >> >> E.g., comparing(String::length) == comparing( (Function) String::length ) == comparing( (String s)->s.length() ). >> >> This extra help to the compiler is needed because it doesn't know IntFunction is preferable to Function, when resolving overloadings. >> >> That is because IntFunction does not extend Function. >> >> Is that right? > or because in the inference mechanism, Integer is not recognized as the > boxing of an int, > or if you prefer T -> int is not a specialization of T -> Integer. To be a little more specific. The way the JLS specifies how to find the set of applicable methods works in 3 phase, it first only consider the type without boxing or varargs, then boxing and then boxing and varargs. This algorithm has two purposes. One is that it was backward compatible with the way the set of applicable methods was calculated before java 5 but in that case only two phases (instead of 3) are enough. The other purpose is that it provides specialization, if there is two possible candidates, one that does boxing and the other that doesn't boxing, the one that does no boxing will be chosen. I believe the same strategy should be used when comparing function type. > >> ? John >> R?mi From jed at wesleysmith.io Tue Jun 4 17:06:44 2013 From: jed at wesleysmith.io (Jed Wesley-Smith) Date: Wed, 5 Jun 2013 10:06:44 +1000 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: Map>> is clearly a straw-man. It does not make any sense to have a Map that has an optional key, nor does it make any sense to have an optional result, map already is a partial function! Regardless, "large" generic types are not by themselves scary ? indeed, they are very useful. We already have the ability to hide complex product types at the value level, we just need a way to alias them at the type level. Option is not merely useful as a result type. It is useful anywhere you wish to indicate that a value is optional. For instance, in an input form in a GUI there may be non-mandatory input fields, or there may be inputs to a method that are not necessary for the caller to supply. You may consider overloading in the second case, but for a form structure this can prove unwieldy. Elsewhere, you state "Those from an FP background will clearly see it as something different (if related) and continue to be disappointed (Java isn't going to satisfy them no matter what).". I would like to politely disagree (having been doing exactly that for years now), and also to make the claim that you are yourself a functional programmer. JodaTime fought the battle to bring immutability to a date API and is clearly superior to the previous library for being so. Immutability is a corner-stone of what makes FP ? the ability to program with values. There is no need to believe there is a disconnect, or that you are somehow on the "other side" from functional programmers. We are all on the same side, trying to make better libraries and applications that are easier to reason about, easier to write and easier to maintain. cheers, jed. On 5 June 2013 01:13, Stephen Colebourne wrote: > Optional is, and will continue to be, a key debating point for those > arguing for more FP. The pressure to make it more powerful will > continue, especially given similar named features in other languages. > > Meanwhile I continue to fear Map>> and > the like. The generics type system in Java simply isn't good enough to > be doing anything like that, even if it were remotely desirable. > > Where the class is useful is in the return position. As Brian says "I > think where we've tried to land is: do things that encourage people to > use Optional only in return position". > > However, the one thing that hasn't been done is to name it as such. > Simply rename "Optional" to "OptionalResult", or just "Result" and > many of the issues go away. Those from an FP background will clearly > see it as something different (if related) and continue to be > disappointed (Java isn't going to satisfy them no matter what). More > importantly, Java developers will only use the class in the return > type position, simply because of its name. > > Of course it doesn't prevent Map>>, but it > makes it much less likely just because the name no longer makes sense. > If it is used in that way, its probably because it really is a > collection of earlier results. > > Finally, I'd note that if named Result/OptionalResult, I don't overly > mind which set of methods are on it or that it is a box. So long as > there is the ability to query it using a simple if statement. > > Stephen > > > > On 24 May 2013 21:15, Brian Goetz wrote: > > Optional has obvious upsides and downsides. Some of the downsides are: > > - It's a box. Boxing can be heavy. > > - The more general-purpose value-wrapper classes you have, the more some > > people fear an explosion of unreadable types like > > Map>, List > List>> in API signatures. > > > > I think where we've tried to land is: do things that encourage people to > use > > Optional only in return position. These methods make it more useful in > > return position while not increasing the temptation to use it elsewhere > any > > more than we already have. Hence "mostly harmless". > > > > > > On 5/24/2013 4:10 PM, Tim Peierls wrote: > >> > >> On Fri, May 24, 2013 at 3:20 PM, Brian Goetz >> > wrote: > >> > >> Proposed spec for methods on Optional, which would have the obvious > >> counterparts in Optional{Int,Long,Double}. > >> > >> These methods are known to be useful and seem mostly harmless now > >> that other things have settled. (I don't think they greatly > >> increase the moral hazard of Optional in general, and they do make > >> it more expressive.) > >> > >> > >> I'm in the curious (unique?) position of both desperately wanting > >> Optional and desperately *not* wanting lots of additional methods like > >> these. If the price of having Optional is the presence of these methods, > >> I'll suck it up, but "mostly harmless" is not exactly a ringing > >> endorsement. > >> > >> --tim > > From peter.levart at gmail.com Tue Jun 4 22:49:59 2013 From: peter.levart at gmail.com (Peter Levart) Date: Wed, 05 Jun 2013 07:49:59 +0200 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> <51ADFDBA.30405@oracle.com> Message-ID: <51AED187.3070709@gmail.com> On 06/04/2013 05:09 PM, Paul Sandoz wrote: > On Jun 4, 2013, at 4:46 PM, Aleksey Shipilev wrote: > >> On 06/04/2013 06:17 PM, Paul Sandoz wrote: >>> If i run using interpretive mode -Xint, it works fine, suggesting we >>> are running into a hotspot issue, perhaps a hotspot/GC issue: >> I had reproduced this as well, and seeing >> java.util.stream.SliceOps$SliceTask -> >> java.util.Spliterators$LongArraySpliterator -> >> long[] >> >> ...occupying the most of the heap (3 Gb on my machine). It passes with >> -Xmx7g without problems. With lower heaps, it does a series of full GC, >> which end up with: >> >> [Full GC (Ergonomics) [PSYoungGen: 557248K->555317K(901760K)] >> [ParOldGen: 4190056K->4190056K(4194304K)] 4747304K->4745374K(5096064K), >> [Metaspace: 4142K->4702K(110592K)], 0.0800150 secs] [Times: user=0.19 >> sys=0.00, real=0.08 secs] >> [Full GC (Ergonomics) [PSYoungGen: 557248K->0K(901760K)] [ParOldGen: >> 4190056K->20912K(1710848K)] 4747304K->20912K(2612608K), [Metaspace: >> 4144K->4702K(110592K)], 0.2308390 secs] [Times: user=0.15 sys=0.16, >> real=0.23 secs] >> >> ...so the heap appears to be empty. The application is still munching >> through data in the main thread, which explains why there is no >> parallelism happening: >> > Ah! A light bulb just turned on :-) > > That stack trace is an artifact of the spliterator from iterator returning null due to it trapping an OOME and then the leaf processing kicks in the for the right hand side and the iterator is infinite. So it is a nasty secondary cause due to memory issues. Usually what would happen is the task would get cancelled. > > My conclusion is that those iterator form spliterators should never throw OOME. > > Still it does not explain why OOMEs are so happening for what seem like reasonable heap sizes (especially when interpreted mode works OK). Hi Paul, I don't know if this is the case here, but interpreted mode is much slower in executing the code than compiled, therefore it is much slower at allocating objects so (young) GC can keep-up with allocation (in possibly multiple threads) whereas in compiled mode it presumably can't. Are you using default (single-threaded) GC for young/old generation? If you're allocating in multiple threads, then perhaps GC should be allowed to collect garbage in multiple threads too. Try this: -XX:+UseParallelGC -XX:ParallelGCThreads=(number of cores/threads in your box) -XX:+UseParallelOldGC Regards, Peter > > Paul. > > >> "main" #1 prio=5 os_prio=0 tid=0x00007fa290009800 nid=0x7342 runnable >> [0x00007fa298ed1000] >> java.lang.Thread.State: RUNNABLE >> at java.util.stream.Nodes$SpinedNodeBuilder.accept(Nodes.java:1248) >> at >> java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:176) >> at java.util.stream.LongPipeline$3$1.accept(LongPipeline.java:230) >> at >> java.util.PrimitiveIterator$OfLong.forEachRemaining(PrimitiveIterator.java:166) >> at java.util.stream.LongStream$1.forEachRemaining(LongStream.java) >> at >> java.util.Spliterators$LongIteratorSpliterator.forEachRemaining(Spliterators.java:2029) >> at java.util.Spliterator$OfLong.forEachRemaining(Spliterator.java:744) >> at >> java.util.Spliterators$LongIteratorSpliterator.forEachRemaining(Spliterators.java) >> at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482) >> at >> java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472) >> at java.util.stream.SliceOps$SliceTask.doLeaf(SliceOps.java:606) >> at java.util.stream.SliceOps$SliceTask.doLeaf(SliceOps.java:553) >> at java.util.stream.AbstractTask.compute(AbstractTask.java:312) >> at java.util.concurrent.CountedCompleter.exec(CountedCompleter.java:710) >> at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289) >> at java.util.concurrent.ForkJoinTask.doInvoke(ForkJoinTask.java:385) >> at java.util.concurrent.ForkJoinTask.invoke(ForkJoinTask.java:717) >> at java.util.stream.SliceOps$1.opEvaluateParallelLazy(SliceOps.java:150) >> at >> java.util.stream.AbstractPipeline.sourceSpliterator(AbstractPipeline.java:442) >> at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:230) >> at java.util.stream.LongPipeline.reduce(LongPipeline.java:447) >> at java.util.stream.LongPipeline.sum(LongPipeline.java:405) >> at java.util.stream.ReferencePipeline.count(ReferencePipeline.java:526) >> at OOM.firstNPrimes(OOM.java:24) >> at OOM.main(OOM.java:11) >> >> >> -Aleksey. > From peter.levart at gmail.com Tue Jun 4 23:14:48 2013 From: peter.levart at gmail.com (Peter Levart) Date: Wed, 05 Jun 2013 08:14:48 +0200 Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: <51AED758.5010609@gmail.com> On 06/04/2013 09:03 PM, Paul Sandoz wrote: > Digging more into the problem... of course i made the fatal/silly mistake of prematurely blaming hotspot/gc :-) > > In addition to the catching of the OOME the other problem is the main task creation loop is too aggressive creating tasks for a spliterator from iterator. Tasks are created faster than they can be processed and this gets worse as the numbers get larger since it takes more time to check if a number is a prime number. Normally this is ok as spliterators are light-weight, but the spliterator from iterator copies stuff into an array of increasing size. But how do you explain that you have no problems when running in interpreted mode? Is the ratio of execution speed of "task creation" : "task execution" lower in interpreted mode than in compiled mode? Regards, Peter > > In such a case we need that main task loop to take part in processing other tasks. Ideally we would know the tree-shape produced by a spliterator but failing that we can do something in the slice op task. > > I am also pondering getting rid of the slice op task all-together and replacing with a special skip/limit spliterator using the same techniques as the spliterator from iterator, there by side-stepping the problem. > > Paul. > > > On Jun 4, 2013, at 5:15 PM, "Mallwitz, Christian" wrote: > >> First of all adding -Xint seems to make the problem to go away for me as well: using a parallel stream will not use much more heap than a serial stream _and_ there is a speed up >> >> When not using -Xint the output from the isPrime predicate is reporting that increasingly bigger n are tested way beyond the 4,000,000 from the serial stream case (GC output removed): >> >> 10.077: 131349505 >> 74.073: 137916980 >> 141.865: 144812829 >> 214.485: 152053470 >> 292.511: 159656143 >> ... >> ... >> ... >> >> During that time heap usage slowly creaps up until the heap is completely filled and an OOM occurs for me. >> >> Christian >> >> -----Original Message----- >> From: Paul Sandoz [mailto:paul.sandoz at oracle.com] >> Sent: Tuesday, June 04, 2013 3:17 PM >> To: Mallwitz, Christian >> Cc: 'lambda-dev at openjdk.java.net' >> Subject: Re: Regression (b92): OOM on filter/limit operation on unbound/parallel stream >> >> Hi Christian, >> >> I can reproduce your behaviour of your test programming taking ages to run, but i needed to increase mx to 2g. Initially i notice lots of GCs then it starts slowing down with the occasional "GC (Allocation Failure)". Something fishy is going on here, it is very slow with one core pegged at 100% and Visual VM is showing that the used heap is way less than the heap size. >> >> If i run using interpretive mode -Xint, it works fine, suggesting we are running into a hotspot issue, perhaps a hotspot/GC issue: >> >> $ java -Xint -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps OOM2 >> -XX:ClassMetaspaceSize=104857600 -XX:InitialHeapSize=134217728 -XX:MaxHeapSize=1073741824 -XX:+PrintCommandLineFlags -XX:+PrintGC -XX:+PrintGCTimeStamps -XX:+UseCompressedKlassPointers -XX:+UseCompressedOops -XX:+UseParallelGC >> 3.766: [GC (Allocation Failure) 32767K->656K(125632K), 0.0010730 secs] >> 8.476: [GC (Allocation Failure) 33424K->592K(125632K), 0.0008800 secs] >> 13.520: 3999970 >> firstNPrimes ( 283146, false): 283146 >> 13.623: [GC (Allocation Failure) 33360K->960K(125632K), 0.0010140 secs] >> 14.019: [GC (Allocation Failure) 33728K->6244K(125632K), 0.0035470 secs] >> 14.530: [GC (Allocation Failure) 39004K->11608K(124864K), 0.0050110 secs] >> 15.034: [GC (Allocation Failure) 43608K->23289K(123776K), 0.0071630 secs] >> 15.499: [GC (Allocation Failure) 48175K->27989K(129600K), 0.0033540 secs] >> 15.946: [GC (Allocation Failure) 53141K->38138K(126336K), 0.0083030 secs] >> 15.878: 4199968 >> 16.043: 4475905 >> 16.416: [GC (Allocation Failure) 57018K->24262K(111040K), 0.0027570 secs] >> firstNPrimes ( 283146, true): 283146 >> >> >>> From the GC output it looks like an ~ speed up of about 3-4x. >> I can even run with a lower mx value. Interestingly if i lower mx to say 32m i start running into similar issues. I have noticed GC output continually outputting a full GC. >> >> -- >> >> Because iterator is an ordered and infinite source then hooking it up to limit will always requiring buffering when going parallel. We have managed to reduce some of the internal memory churn but this really comes down to better documentation. >> >> To obtain 283_146 primes at least 3_999_971 elements will need to be buffered. The LongStream.iterate method extracts parallelism by sequentially copying a prefix of elements into an array and growing the array over time. Each array will be operated on by an F/J task. To get any parallel speed up the cost of processing elements must be higher than copying those elements into an array; i think primes is a good example of where this should work well. >> >> Note that a limit up to N does not guarantee that up to N elements will be processed upstream, it may be more, specially so given the array sizes increasing of iterate. >> >> Using boxed values is definitely gonna kill performance since it will mess up the caches, while the array of Long[] is OK the actually long values could be anywhere in memory. >> >> Paul. >> >> On Jun 4, 2013, at 2:02 PM, "Mallwitz, Christian" wrote: >> >>> Hi, >>> >>> Re-reporting problem for build 92: the filter/limit on unbound, parallel stream operation behaves very weird. How weird? Well: >>> >>> - the serial version uses about 16M of heap, the parallel gobbles up all of the 1GB defined as max >>> - it throws an OOM after running for hours while it is __NOT__ garbage collecting much but >>> - the filter predicate is called on millions of elements more than what can be observed using a serial stream >>> - I can't observe any parallelism (based on number of cores and system load - 4 cores and only 25% load) >>> >>> I'm using 1.8.0-ea-lambda-nightly-h4544-20130526-b92-b00 on a Windows XP 32 bit machine - VM args: -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps >>> >>> My test program tries to find the first 283,146 prime numbers (which are all below 4,000,000). It executes the filter/limit operation on a serial stream first and prints out numbers tested for primality occasionally. >>> >>> Thanks >>> Christian >>> >>> >>> >>> >>> >>> package com.snuffbumble.lambda; >>> >>> import java.util.stream.LongStream; >>> import java.util.stream.Stream; >>> >>> public class OOM { >>> >>> public static void main(String... ignored) { >>> >>> // first 283_146 primes are all < 4_000_000 >>> >>> firstNPrimes(283_146, getIteratorBasedStream(false)); // only minor GC - max heap 16M >>> firstNPrimes(283_146, getIteratorBasedStream(true)); // full GC - up to max heap 1GB and subsequent OOM >>> } >>> >>> private static Stream getIteratorBasedStream(boolean produceParallelStream) { >>> Stream s = LongStream.iterate(1L, n -> n + 1L).boxed(); >>> return produceParallelStream ? s.parallel() : s; >>> } >>> >>> private static void firstNPrimes(int n, Stream stream) { >>> System.out.println(String.format("firstNPrimes (%8d, %5b): %8d", n, stream.isParallel(), >>> stream >>> .filter(OOM::isPrime) >>> .limit(n) // limit after primality test >>> .count())); >>> } >>> >>> private static long start_millis = System.currentTimeMillis(); >>> private static long max_n_seen = 3_999_970L; >>> >>> private static boolean isPrime(long n) { >>> >>> if (n >= max_n_seen) { >>> System.out.println(String.format("%.3f: %d", (System.currentTimeMillis() - start_millis)/1000.0, n)); >>> max_n_seen = n + (n/20L); // new max_n_seen 5% larger than current n >>> } >>> >>> if (n <= 1) { return false; } >>> if (n == 2) { return true; } >>> if (n % 2 == 0) { return false; } >>> for (int i = 3; i <= (int) Math.sqrt(n); i += 2) { if (n % i == 0) return false; } >>> return true; >>> } >>> } >>> >>> >> > From ted at tedneward.com Tue Jun 4 23:57:47 2013 From: ted at tedneward.com (Ted Neward) Date: Tue, 4 Jun 2013 23:57:47 -0700 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: <099401ce61b9$fcf1eb80$f6d5c280$@tedneward.com> *NEVER* had that reaction from anyone, when showing them home-grown Optional types (in a variety of different in-house Java libraries). Ted Neward Leading, Speaking, Consulting, Writing http://www.tedneward.com > -----Original Message----- > From: lambda-dev-bounces at openjdk.java.net [mailto:lambda-dev- > bounces at openjdk.java.net] On Behalf Of Zhong Yu > Sent: Tuesday, June 04, 2013 2:26 PM > To: Clayton Wohl > Cc: lambda-dev at openjdk.java.net > Subject: Re: Optional -> OptionalResult > > "Option" sounds like the producer has a choice, it can choose to produce > something or nothing based on some private/undisclosed reasons. That > connotation may mislead people into using it for the wrong reasons, e.g. as > input type. > > On Tue, Jun 4, 2013 at 3:36 PM, Clayton Wohl > wrote: > > Why would "Map>>" be more of a > concern > > than any other ridiculous combination of generics nesting? How about > > List>>>>? > > > > Usually, devs don't nest optionals inside of lists/maps. I'm sure it > > will happen in some edge case, but in the Scala code or the Functional > > Java code bases I've worked in, people do not do that, just like they > > don't do lots of other crazy combinations of generics that are > > technically possible in Java 5+. > > > > For the name, I like Option/Optional, however, that's a relatively > > minor detail and I will be happy with whatever the JDK team chooses. > > > > Stephen, the reasoning for an Optional type with map/flatMap/forEach > > functionality is very convincing and I don't believe it's appeal is > > limited to elite FP experts, which I am definitely not. I've seen lots > > of junior Java devs appreciate the same functionality in Functional > > Java. Your opposition to this does not seem to have a grounding in reason. > > > > BTW, the new date/time library you've worked on looks amazing. I've > > been using the plug-in version in my personal projects for years, and > > I am excited to see it broadly adopted into the core JDK 8. > > > > > > On Tue, Jun 4, 2013 at 10:13 AM, Stephen Colebourne > joda.org> wrote: > >> Optional is, and will continue to be, a key debating point for those > >> arguing for more FP. The pressure to make it more powerful will > >> continue, especially given similar named features in other languages. > >> > >> Meanwhile I continue to fear Map>> and > >> the like. The generics type system in Java simply isn't good enough > >> to be doing anything like that, even if it were remotely desirable. > > From paul.sandoz at oracle.com Wed Jun 5 02:03:22 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Wed, 5 Jun 2013 02:03:22 -0700 (PDT) Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: <51AED758.5010609@gmail.com> References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> <51AED758.5010609@gmail.com> Message-ID: On Jun 5, 2013, at 8:14 AM, Peter Levart wrote: > On 06/04/2013 09:03 PM, Paul Sandoz wrote: >> Digging more into the problem... of course i made the fatal/silly mistake of prematurely blaming hotspot/gc :-) >> >> In addition to the catching of the OOME the other problem is the main task creation loop is too aggressive creating tasks for a spliterator from iterator. Tasks are created faster than they can be processed and this gets worse as the numbers get larger since it takes more time to check if a number is a prime number. Normally this is ok as spliterators are light-weight, but the spliterator from iterator copies stuff into an array of increasing size. > > But how do you explain that you have no problems when running in interpreted mode? I can induce a problem in interpretive mode if i reduce the maximum memory. It basically causes the OOME which then causes the spin loop. > Is the ratio of execution speed of "task creation" : "task execution" lower in interpreted mode than in compiled mode? > That would be by guess. Intuitively i would have expected things to balance out but i am guessing GCs result in larger pauses to the main thread (is that possible?) and perhaps the loop to calculate primes is proportionally much faster in interpretive mode than the creation of tasks. I have a working hack in AbstractTask so i can get the max memory down to 32m: public final void compute() { @SuppressWarnings("unchecked") K task = (K) this; while (task.canCompute()) { if (task.spliterator.estimateSize() == Long.MAX_VALUE) { ForkJoinPool p = ForkJoinPool.commonPool(); while (p.hasQueuedSubmissions() && p.getQueuedSubmissionCount() > 8) { p.awaitQuiescence(0, TimeUnit.MILLISECONDS); } } Spliterator split; if (!task.suggestSplit() || (split = task.spliterator.trySplit()) == null) { task.setLocalResult(task.doLeaf()); task.tryComplete(); return; } else { K l = task.leftChild = task.makeChild(split); K r = task.rightChild = task.makeChild(task.spliterator); task.spliterator = null; task.setPendingCount(1); l.fork(); task = r; } } } For a spliterator from iterator of infinite size this basically enables the root task, on the main thread, to help out if there are pending tasks. I think in general this is probably useful for any large estimate e.g. >= 1 >> 24 to protect against spliterator from iterator since we cannot accurately detect them (although i have pondered a spliterator characteristic e.g. RIGHTBALANCED) Paul. From paul.sandoz at oracle.com Wed Jun 5 02:09:39 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Wed, 5 Jun 2013 11:09:39 +0200 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: <617ABF00-1C6F-4208-85CE-0C139EB69858@oracle.com> On Jun 5, 2013, at 2:06 AM, Jed Wesley-Smith wrote: > Map>> is clearly a straw-man. +1 Paul. From scolebourne at joda.org Wed Jun 5 02:20:15 2013 From: scolebourne at joda.org (Stephen Colebourne) Date: Wed, 5 Jun 2013 10:20:15 +0100 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: On 5 June 2013 01:06, Jed Wesley-Smith wrote: > Map>> is clearly a straw-man. It does not make any sense to > have a Map that has an optional key, nor does it make any sense to have an > optional result, map already is a partial function! Regardless, "large" > generic types are not by themselves scary ? indeed, they are very useful. We > already have the ability to hide complex product types at the value level, > we just need a way to alias them at the type level. Here is what Tim Pierls wrote: On 4 June 2013 15:57, Tim Peierls wrote: > I try to use Optional purely as a return type, and I try to avoid using > monstrosities like List> (or worse) in an API. I confess that > in my first flush of excitement at having Optional, I went way overboard > and did, in fact, create some truly horrible method signatures, but the > crime conveys its own punishment, and I quickly learned what not to do. While Tim clearly learnt the mistake, the reality is that APIs were produced with poor method signatures. Developers will over-use Optional, at least in part because the Scala community pushes it as the solution to null, which it isn't. The consistent rejection of adding the most basic language tools for null (?. and ?:) is another factor (never mind null in the type system). Developers know that null is a right royal pain and a problem they'd love to solve. Since they are forbiidden useful language level solutions, some will see Optional as the new nirvana and thus over-use it. To call it a straw man is to misunderstand why better null-handling in Java was repeatedly voted by developers as the language change they want. > Option is not merely useful as a result type. It is useful anywhere you wish > to indicate that a value is optional. For instance, in an input form in a > GUI there may be non-mandatory input fields, or there may be inputs to a > method that are not necessary for the caller to supply. You may consider > overloading in the second case, but for a form structure this can prove > unwieldy. No, I'd just use null for something that is optional. It what Java has used for donkeys years, what works with the JavaBean spec and doesn't require extra thinking. What it does require is documenting whether the parameter/return value can be null or not, but that should be done anyway. The key point is that Java (and Scala) still have null. Null cannot be removed or eliminated. Any variable declared as type Optional can still be set to null. Optional is a false promise, making you feel good, but not actually removing the danger of null. > JodaTime fought the battle to > bring immutability to a date API and is clearly superior to the previous > library for being so. Immutability is a corner-stone of what makes FP ? the > ability to program with values. There is no need to believe there is a > disconnect, or that you are somehow on the "other side" from functional > programmers. We are all on the same side, trying to make better libraries > and applications that are easier to reason about, easier to write and easier > to maintain. Java is a mutable language, far from the ideals of FP. Joda-Time and JSR-310 provide an immutable low-level library, which has real and tangible benefits. But trying to expand that immutability beyond low-level libraries given (a) the language facilities available in Java, and (b) the history of Java, is at best painful. Stephen From mark at talios.com Wed Jun 5 03:32:09 2013 From: mark at talios.com (Mark Derricutt) Date: Wed, 05 Jun 2013 22:32:09 +1200 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: <51AF13A9.3020207@talios.com> I don't want to nitpick, but Map>> isn't even a valid type for Map, the least your have would be Map>, IMHO this would actually be valid in the case where you need to disambiguate an empty list, from NO list. However, if Map had a method that returned an Optional if the value from absent from the map, say Map#find, Map#getOptional or Map#getResult you could train developers into not putting Optionals directly in the map to start with. Something like: String name = map.getResult("firstName").or(""); reads quite well. Jed Wesley-Smith wrote: > Map>> is clearly a straw-man. It does not make any sense > to have a Map that has an optional key, From scolebourne at joda.org Wed Jun 5 03:47:31 2013 From: scolebourne at joda.org (Stephen Colebourne) Date: Wed, 5 Jun 2013 11:47:31 +0100 Subject: Optional -> OptionalResult In-Reply-To: <51AF13A9.3020207@talios.com> References: <51AF13A9.3020207@talios.com> Message-ID: On 5 June 2013 11:32, Mark Derricutt wrote: > I don't want to nitpick, but Map>> isn't even a valid type for Map Thats why I use an IDE ;-) > However, if Map had a method that returned an Optional if the value from absent from the map, say Map#find, Map#getOptional or Map#getResult you could train developers into not putting Optionals directly in the map to start with. > > Something like: > > String name = map.getResult("firstName").or(""); I agree. In the return type position it works well. Given your proposed method is getResult(), it suggests that the returned class would make sense to be called Result. Thats the real point of this thread. Stephen From peter.levart at gmail.com Wed Jun 5 03:49:52 2013 From: peter.levart at gmail.com (Peter Levart) Date: Wed, 05 Jun 2013 12:49:52 +0200 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: <51AF17D0.9030807@gmail.com> On 06/05/2013 11:20 AM, Stephen Colebourne wrote: > No, I'd just use null for something that is optional. It what Java has > used for donkeys years, what works with the JavaBean spec and doesn't > require extra thinking. What it does require is documenting whether > the parameter/return value can be null or not, but that should be done > anyway. I concur! When Optional was first introduced to Stream API, I thought that it's intention was to actually enable the API to be non-ambiguous in places like Stream.findFirst(), etc. In a sense that Map.get(key) method is ambiguous (null return can mean two things)... But as current Java Optional can not be a container for null value, Streams containing null elements will throw NPE when invoking methods like findFirst() on them. So if the decision was to not fully support null transparency in Stream API the ambiguity of null return from findFirst() and such could be solved in exactly the same way as it is solved now, but without introducing Optional class: - null return means no such element - if null is encountered as element of the stream, findFirst() and such then throw NPE. I'm not talking about "how nice" the code looks when using such API but "what can" be accomplished by using it. Of course with language support like ?. and ?: the code would could look much nicer even without Optional. Regards, Peter From forax at univ-mlv.fr Wed Jun 5 05:42:39 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Wed, 05 Jun 2013 14:42:39 +0200 Subject: Optional -> OptionalResult In-Reply-To: <51AF17D0.9030807@gmail.com> References: <51AF17D0.9030807@gmail.com> Message-ID: <51AF323F.2070608@univ-mlv.fr> On 06/05/2013 12:49 PM, Peter Levart wrote: > I'm not talking about "how nice" the code looks when using such API but > "what can" be accomplished by using it. Of course with language support > like ?. and ?: the code would could look much nicer even without Optional. +1, and better if Optional is an annotation/keyword, that forces users to use ?., ?: or a null check so have the same guarantee that Optional as a class without the overhead and without a way to stick Optional in a middle of angle brackets. A lot of people find that Java should do the boxing transparently, but adding a class Optional/Option/Maybe to manage null goes in the opposite direction by forcing users and writers of API to do the boxing (of null) by hand. Basically I see Optional/Option/Maybe (or any boxing of null) as a solution based on a design pattern. Most of the design patterns are created because of a lack of support in the language. So instead of using a design pattern why not adding support for null management directly in the language, we are talking about Java here, a language that has always evolve and will continue to evolve. > > Regards, Peter > > cheers, R?mi From maurizio.cimadamore at oracle.com Wed Jun 5 06:16:17 2013 From: maurizio.cimadamore at oracle.com (maurizio.cimadamore at oracle.com) Date: Wed, 05 Jun 2013 13:16:17 +0000 Subject: hg: lambda/lambda/langtools: 8013789: Compiler should emit bridges in interfaces Message-ID: <20130605131623.2117048F87@hg.openjdk.java.net> Changeset: e95406cfa4aa Author: mcimadamore Date: 2013-06-05 14:15 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/e95406cfa4aa 8013789: Compiler should emit bridges in interfaces Fixed issue with metafactory bridge generation in the face of separate compilation/older classfiles. Added exhaustive test support. ! src/share/classes/com/sun/tools/javac/code/Types.java + test/tools/javac/lambda/bridge/TestMetafactoryBridges.java From ali.ebrahimi1781 at gmail.com Wed Jun 5 08:52:06 2013 From: ali.ebrahimi1781 at gmail.com (Ali Ebrahimi) Date: Wed, 5 Jun 2013 20:22:06 +0430 Subject: Optional -> OptionalResult In-Reply-To: <51AF323F.2070608@univ-mlv.fr> References: <51AF17D0.9030807@gmail.com> <51AF323F.2070608@univ-mlv.fr> Message-ID: +1 for language support. Maybe using new jsr 308 and built-in java compiler plugin: @NotNull checker @NotNull String str = null; //compile error @NotNull String test(@NotNull String a){ ... return null; //compile error } test(null) //compile error String nullable = someMethod(); @NotNull String nonNullable = nullable; //compile error: incompatible type this way we guarantee don't get NullPointerException anyway and don't need handle that. another and similar solution is introducing a syntactic sugar for non-nullable types. @NotNull String <=> String! On Wed, Jun 5, 2013 at 5:12 PM, Remi Forax wrote: > On 06/05/2013 12:49 PM, Peter Levart wrote: > > I'm not talking about "how nice" the code looks when using such API but > > "what can" be accomplished by using it. Of course with language support > > like ?. and ?: the code would could look much nicer even without > Optional. > > +1, > > and better if Optional is an annotation/keyword, that forces users to > use ?., ?: or a null check > so have the same guarantee that Optional as a class without the overhead > and without a way to stick Optional in a middle of angle brackets. > > A lot of people find that Java should do the boxing transparently, but > adding a class Optional/Option/Maybe > to manage null goes in the opposite direction by forcing users and > writers of API to do the boxing (of null) by hand. > > Basically I see Optional/Option/Maybe (or any boxing of null) as a > solution based on a design pattern. > Most of the design patterns are created because of a lack of support in > the language. > So instead of using a design pattern why not adding support for null > management directly in the language, > we are talking about Java here, a language that has always evolve and > will continue to evolve. > > > > > Regards, Peter > > > > > > cheers, > R?mi > > > From zhong.j.yu at gmail.com Wed Jun 5 09:23:32 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Wed, 5 Jun 2013 11:23:32 -0500 Subject: Optional -> OptionalResult In-Reply-To: References: <51AF13A9.3020207@talios.com> Message-ID: On Wed, Jun 5, 2013 at 5:47 AM, Stephen Colebourne wrote: > On 5 June 2013 11:32, Mark Derricutt wrote: >> I don't want to nitpick, but Map>> isn't even a valid type for Map > Thats why I use an IDE ;-) > >> However, if Map had a method that returned an Optional if the value from absent from the map, say Map#find, Map#getOptional or Map#getResult you could train developers into not putting Optionals directly in the map to start with. >> >> Something like: >> >> String name = map.getResult("firstName").or(""); > > I agree. In the return type position it works well. Given your > proposed method is getResult(), it suggests that the returned class > would make sense to be called Result. Thats the real point of this > thread. Yes, can we agree on a small thing first, that "Optional" is a nonsensical name for the class. Google "define optional" Available to be chosen but not obligatory Left to choice; not compulsory or automatic. possible but not compulsory; left to personal choice left to one's choice; not required or mandatory - Jackets are required at the restaurant, but ties are optional. - Many optional features are available on this car. - Registration is optional, not mandatory. The meaning of the word in plain English has nothing to do with the contract of Stream.findFirst() etc. From misterm at gmail.com Wed Jun 5 09:31:57 2013 From: misterm at gmail.com (Michael Nascimento) Date: Wed, 5 Jun 2013 13:31:57 -0300 Subject: Collectors.sumBy Message-ID: Hi folks, Is there any good reason I cannot see for Collectors.sumBy, giving one could use mapToLong().sum() and avoid the costs of boxing? Regards, Michael From paul.sandoz at oracle.com Wed Jun 5 09:50:45 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Wed, 5 Jun 2013 18:50:45 +0200 Subject: Collectors.sumBy In-Reply-To: References: Message-ID: On Jun 5, 2013, at 6:31 PM, Michael Nascimento wrote: > Hi folks, > > Is there any good reason I cannot see for Collectors.sumBy, giving one > could use mapToLong().sum() and avoid the costs of boxing? > Such Collector can be used with mapping, groupingBy and partitioningBy, e.g. Stream s = ... Map m = s.collect(groupingBy(Function::identity, sumBy(this::mapFooToLong))); Paul. From misterm at gmail.com Wed Jun 5 09:54:42 2013 From: misterm at gmail.com (Michael Nascimento) Date: Wed, 5 Jun 2013 13:54:42 -0300 Subject: Collectors.sumBy In-Reply-To: References: Message-ID: Great, thanks Paul! Regards, Michael On Wed, Jun 5, 2013 at 1:50 PM, Paul Sandoz wrote: > > On Jun 5, 2013, at 6:31 PM, Michael Nascimento wrote: > >> Hi folks, >> >> Is there any good reason I cannot see for Collectors.sumBy, giving one >> could use mapToLong().sum() and avoid the costs of boxing? >> > > Such Collector can be used with mapping, groupingBy and partitioningBy, e.g. > > Stream s = ... > Map m = s.collect(groupingBy(Function::identity, sumBy(this::mapFooToLong))); > > Paul. From mike.duigou at oracle.com Wed Jun 5 15:21:31 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 05 Jun 2013 22:21:31 +0000 Subject: hg: lambda/lambda/jaxws: 2 new changesets Message-ID: <20130605222146.BA1B248FCA@hg.openjdk.java.net> Changeset: 7386eca865e1 Author: katleman Date: 2013-05-30 10:58 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxws/rev/7386eca865e1 Added tag jdk8-b92 for changeset a0f604766ca1 ! .hgtags Changeset: a9a16090360a Author: mduigou Date: 2013-06-05 13:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxws/rev/a9a16090360a Merge ! .hgtags - .jcheck/conf From mike.duigou at oracle.com Wed Jun 5 15:21:31 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 05 Jun 2013 22:21:31 +0000 Subject: hg: lambda/lambda/corba: 2 new changesets Message-ID: <20130605222136.27DE448FC9@hg.openjdk.java.net> Changeset: 8dc9d7ccbb2d Author: katleman Date: 2013-05-30 10:57 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/corba/rev/8dc9d7ccbb2d Added tag jdk8-b92 for changeset 717aa26f8e0a ! .hgtags Changeset: 37e8d749a93c Author: mduigou Date: 2013-06-05 13:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/corba/rev/37e8d749a93c Merge ! .hgtags - .jcheck/conf From mike.duigou at oracle.com Wed Jun 5 15:21:37 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 05 Jun 2013 22:21:37 +0000 Subject: hg: lambda/lambda/nashorn: 45 new changesets Message-ID: <20130605222306.445DE48FCC@hg.openjdk.java.net> Changeset: 1c7481ac7fe0 Author: katleman Date: 2013-05-30 10:58 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/1c7481ac7fe0 Added tag jdk8-b92 for changeset dee23cce5235 ! .hgtags Changeset: 80d4db063d5a Author: jlaskey Date: 2013-05-14 11:15 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/80d4db063d5a 8014512: Exclude testing and infrastructure packages from code coverage Reviewed-by: sundar Contributed-by: james.laskey at oracle.com ! make/code_coverage.xml Changeset: eeed4db61215 Author: jlaskey Date: 2013-05-14 11:16 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/eeed4db61215 Merge - src/jdk/nashorn/internal/ir/LineNumberNode.java - src/jdk/nashorn/internal/ir/Location.java - test/script/trusted/logcoverage.js Changeset: fc20983ef38e Author: attila Date: 2013-05-14 19:18 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/fc20983ef38e 8011718: binding already bound function with extra arguments fails Reviewed-by: jlaskey, sundar ! src/jdk/nashorn/internal/runtime/ScriptFunctionData.java + test/script/basic/JDK-8011718.js + test/script/basic/JDK-8011718.js.EXPECTED Changeset: f88a4818a4dc Author: lagergren Date: 2013-05-14 19:56 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/f88a4818a4dc 8014426: Original exception no longer thrown away when a finally rethrows Reviewed-by: attila, jlaskey ! src/jdk/nashorn/internal/codegen/CodeGenerator.java ! src/jdk/nashorn/internal/codegen/Lower.java ! src/jdk/nashorn/internal/ir/CatchNode.java ! src/jdk/nashorn/internal/ir/ThrowNode.java ! src/jdk/nashorn/internal/parser/Parser.java + test/script/basic/JDK-8014426.js + test/script/basic/JDK-8014426.js.EXPECTED Changeset: 64ef1aeaeb4e Author: attila Date: 2013-05-15 10:28 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/64ef1aeaeb4e 8014639: Remove debug flag from test runs Reviewed-by: hannesw, lagergren ! make/project.properties Changeset: b37eb709ae27 Author: attila Date: 2013-05-15 14:54 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/b37eb709ae27 8014646: Update the Java interop documentation in the Java Scripting Programmer's Guide Reviewed-by: jlaskey, hannesw, lagergren ! docs/JavaScriptingProgrammersGuide.html Changeset: 1eaa542cc8e2 Author: sundar Date: 2013-05-15 19:45 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/1eaa542cc8e2 8012305: Function.bind can't be called on prototype function inside constructor Reviewed-by: lagergren, attila + test/script/basic/JDK-8012305.js + test/script/basic/JDK-8012305.js.EXPECTED Changeset: 6344644b81ec Author: jlaskey Date: 2013-05-15 12:09 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/6344644b81ec 8014648: Exclude testing and infrastructure packages from code coverage, round two Reviewed-by: sundar Contributed-by: james.laskey at oracle.com ! make/code_coverage.xml ! src/jdk/nashorn/internal/runtime/options/Option.java ! src/jdk/nashorn/internal/runtime/options/Options.java - src/jdk/nashorn/internal/runtime/options/ValueOption.java ! test/script/basic/allgettersetters.js Changeset: 19e9cd9c7010 Author: attila Date: 2013-05-15 20:21 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/19e9cd9c7010 8014647: Allow class-based overrides to be initialized with a ScriptFunction Reviewed-by: hannesw, jlaskey, sundar ! src/jdk/nashorn/internal/runtime/linker/JavaAdapterBytecodeGenerator.java + test/script/basic/JDK-8014647.js + test/script/basic/JDK-8014647.js.EXPECTED Changeset: ac14a1fb0cab Author: sundar Date: 2013-05-16 14:52 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/ac14a1fb0cab 8009141: Avoid netscape.javascript.JSObject in nashorn code Reviewed-by: lagergren, hannesw + src/jdk/nashorn/api/scripting/JSObject.java ! src/jdk/nashorn/api/scripting/ScriptObjectMirror.java ! src/jdk/nashorn/internal/runtime/linker/JSObjectLinker.java - src/netscape/javascript/JSObject.java ! test/src/jdk/nashorn/api/scripting/ScriptEngineTest.java Changeset: 4c67a692ef97 Author: lagergren Date: 2013-05-16 13:44 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/4c67a692ef97 8013919: Original exception no longer thrown away when a finally rethrows Reviewed-by: jlaskey, sundar ! src/jdk/nashorn/internal/codegen/Lower.java ! src/jdk/nashorn/internal/ir/FunctionNode.java + test/script/basic/JDK-8013919.js + test/script/basic/JDK-8013919.js.EXPECTED Changeset: 98798a6336de Author: hannesw Date: 2013-05-16 19:52 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/98798a6336de 8012359: Increase code coverage in Joni Reviewed-by: jlaskey, lagergren ! make/build.xml - src/jdk/nashorn/internal/runtime/regexp/DefaultRegExp.java + src/jdk/nashorn/internal/runtime/regexp/JdkRegExp.java ! src/jdk/nashorn/internal/runtime/regexp/JoniRegExp.java ! src/jdk/nashorn/internal/runtime/regexp/RegExpFactory.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Analyser.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ArrayCompiler.java - src/jdk/nashorn/internal/runtime/regexp/joni/AsmCompiler.java - src/jdk/nashorn/internal/runtime/regexp/joni/AsmCompilerSupport.java ! src/jdk/nashorn/internal/runtime/regexp/joni/BitSet.java ! src/jdk/nashorn/internal/runtime/regexp/joni/BitStatus.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ByteCodeMachine.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ByteCodePrinter.java - src/jdk/nashorn/internal/runtime/regexp/joni/CaptureTreeNode.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Compiler.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Config.java ! src/jdk/nashorn/internal/runtime/regexp/joni/EncodingHelper.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Lexer.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Matcher.java - src/jdk/nashorn/internal/runtime/regexp/joni/NameEntry.java - src/jdk/nashorn/internal/runtime/regexp/joni/NativeMachine.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Parser.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Regex.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Region.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ScanEnvironment.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ScannerSupport.java ! src/jdk/nashorn/internal/runtime/regexp/joni/StackMachine.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Syntax.java - src/jdk/nashorn/internal/runtime/regexp/joni/UnsetAddrList.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ast/CClassNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/ast/CTypeNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/ast/CallNode.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ast/EncloseNode.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ast/QuantifierNode.java ! src/jdk/nashorn/internal/runtime/regexp/joni/ast/StateNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/AbstractBench.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchGreedyBacktrack.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchRailsRegs.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchSeveralRegexps.java ! src/jdk/nashorn/internal/runtime/regexp/joni/constants/OPCode.java - src/jdk/nashorn/internal/runtime/regexp/joni/constants/Reduce.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/AsciiTables.java ! src/jdk/nashorn/internal/runtime/regexp/joni/encoding/ObjPtr.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/PosixBracket.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/Ptr.java ! src/jdk/nashorn/internal/runtime/regexp/joni/exception/ErrorMessages.java ! src/jdk/nashorn/internal/runtime/regexp/joni/exception/ValueException.java + test/src/jdk/nashorn/internal/runtime/regexp/JdkRegExpTest.java + test/src/jdk/nashorn/internal/runtime/regexp/joni/JoniTest.java Changeset: aa1b6e8c51a0 Author: jlaskey Date: 2013-05-17 14:30 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/aa1b6e8c51a0 8012694: Smoke test fail: Windows JDK-8008554.js - access denied ("java.io.FilePermission" "//C/aurora/sandbox/nashorn~source/test/script/basic/NASHORN-99.js" "read") Reviewed-by: jlaskey Contributed-by: konstantin.shefov at oracle.com Changeset: a92be4c0063b Author: jlaskey Date: 2013-05-17 16:12 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/a92be4c0063b Merge - src/jdk/nashorn/internal/runtime/regexp/DefaultRegExp.java - src/jdk/nashorn/internal/runtime/regexp/joni/AsmCompiler.java - src/jdk/nashorn/internal/runtime/regexp/joni/AsmCompilerSupport.java - src/jdk/nashorn/internal/runtime/regexp/joni/CaptureTreeNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/NameEntry.java - src/jdk/nashorn/internal/runtime/regexp/joni/NativeMachine.java - src/jdk/nashorn/internal/runtime/regexp/joni/UnsetAddrList.java - src/jdk/nashorn/internal/runtime/regexp/joni/ast/CTypeNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/ast/CallNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/AbstractBench.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchGreedyBacktrack.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchRailsRegs.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchSeveralRegexps.java - src/jdk/nashorn/internal/runtime/regexp/joni/constants/Reduce.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/AsciiTables.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/PosixBracket.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/Ptr.java - src/netscape/javascript/JSObject.java Changeset: 1d5a8f1f416e Author: jlaskey Date: 2013-05-17 16:44 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/1d5a8f1f416e 8014823: Reprise - Smoke test fail: Windows JDK-8008554.js - access denied ("java.io.FilePermission" "//C/aurora/sandbox/nashorn~source/test/script/basic/NASHORN-99.js" "read") Reviewed-by: jlaskey Contributed-by: konstantin.shefov at oracle.com ! test/script/basic/JDK-8008554.js Changeset: 92164a5742db Author: lagergren Date: 2013-05-20 16:38 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/92164a5742db 8006069: Range analysis first iteration, runtime specializations Reviewed-by: jlaskey, sundar ! src/jdk/nashorn/internal/codegen/CompilationPhase.java ! src/jdk/nashorn/internal/codegen/Compiler.java ! src/jdk/nashorn/internal/codegen/CompilerConstants.java ! src/jdk/nashorn/internal/codegen/MethodEmitter.java + src/jdk/nashorn/internal/codegen/RangeAnalyzer.java + src/jdk/nashorn/internal/codegen/types/Range.java ! src/jdk/nashorn/internal/codegen/types/Type.java ! src/jdk/nashorn/internal/ir/BinaryNode.java ! src/jdk/nashorn/internal/ir/FunctionNode.java ! src/jdk/nashorn/internal/ir/LexicalContext.java ! src/jdk/nashorn/internal/ir/Node.java ! src/jdk/nashorn/internal/ir/Symbol.java ! src/jdk/nashorn/internal/runtime/CompiledFunction.java ! src/jdk/nashorn/internal/runtime/FinalScriptFunctionData.java ! src/jdk/nashorn/internal/runtime/RecompilableScriptFunctionData.java ! src/jdk/nashorn/internal/runtime/ScriptEnvironment.java ! src/jdk/nashorn/internal/runtime/ScriptFunctionData.java ! src/jdk/nashorn/internal/runtime/resources/Options.properties + test/script/basic/ranges_disabled.js + test/script/basic/ranges_disabled.js.EXPECTED + test/script/basic/ranges_enabled.js + test/script/basic/ranges_enabled.js.EXPECTED + test/script/basic/ranges_payload.js Changeset: b558e19d5de5 Author: sundar Date: 2013-05-20 23:04 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/b558e19d5de5 8014909: ant test compilation error with JoniTest.java Reviewed-by: jlaskey ! make/build.xml Changeset: 1fd18f40ab52 Author: attila Date: 2013-05-20 21:25 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/1fd18f40ab52 8014797: rename Java.toJavaArray/toJavaScriptArray to Java.to/from, respectively. Reviewed-by: jlaskey, sundar ! docs/JavaScriptingProgrammersGuide.html ! docs/source/javaarray.js ! src/jdk/nashorn/api/scripting/resources/engine.js ! src/jdk/nashorn/internal/objects/NativeJava.java ! src/jdk/nashorn/internal/runtime/resources/Messages.properties ! test/script/basic/NASHORN-556.js ! test/script/basic/javaarrayconversion.js ! test/script/currently-failing/logcoverage.js ! test/script/trusted/NASHORN-638.js ! test/script/trusted/NASHORN-653.js Changeset: e955e64fd15d Author: lana Date: 2013-05-22 09:59 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/e955e64fd15d Merge Changeset: 833a9a584b64 Author: attila Date: 2013-05-21 13:40 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/833a9a584b64 8014953: Have NativeJavaPackage throw a ClassNotFoundException when invoked Reviewed-by: jlaskey, sundar ! src/jdk/nashorn/internal/runtime/NativeJavaPackage.java + test/script/basic/JDK-8014953.js + test/script/basic/JDK-8014953.js.EXPECTED Changeset: 288ff54da2a5 Author: jlaskey Date: 2013-05-21 10:17 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/288ff54da2a5 8014827: readLine should accept a prompt as an argument Reviewed-by: sundar, hannesw Contributed-by: james.laskey at oracle.com ! src/jdk/nashorn/internal/runtime/ScriptingFunctions.java Changeset: 07cefc062032 Author: sundar Date: 2013-05-22 16:39 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/07cefc062032 8008947: ScriptEnvironment ctor should be public Reviewed-by: lagergren, attila ! .hgignore ! src/jdk/nashorn/internal/runtime/ScriptEnvironment.java Changeset: 66685c69bdb3 Author: sundar Date: 2013-05-22 19:33 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/66685c69bdb3 8014735: Typed Array, BYTES_PER_ELEMENT should be a class property Reviewed-by: lagergren, jlaskey ! src/jdk/nashorn/internal/objects/ArrayBufferView.java ! src/jdk/nashorn/internal/objects/NativeFloat32Array.java ! src/jdk/nashorn/internal/objects/NativeFloat64Array.java ! src/jdk/nashorn/internal/objects/NativeInt16Array.java ! src/jdk/nashorn/internal/objects/NativeInt32Array.java ! src/jdk/nashorn/internal/objects/NativeInt8Array.java ! src/jdk/nashorn/internal/objects/NativeUint16Array.java ! src/jdk/nashorn/internal/objects/NativeUint32Array.java ! src/jdk/nashorn/internal/objects/NativeUint8Array.java ! src/jdk/nashorn/internal/objects/NativeUint8ClampedArray.java + test/script/basic/JDK-8014735.js + test/script/basic/JDK-8014735.js.EXPECTED ! test/script/basic/NASHORN-377.js Changeset: 8f7553df4503 Author: hannesw Date: 2013-05-22 16:43 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/8f7553df4503 8010804: Review long and integer usage conventions Reviewed-by: jlaskey, sundar ! src/jdk/nashorn/internal/codegen/FoldConstants.java ! src/jdk/nashorn/internal/objects/NativeArray.java ! src/jdk/nashorn/internal/objects/NativeDate.java ! src/jdk/nashorn/internal/runtime/JSType.java + test/script/basic/JDK-8010804.js + test/script/basic/JDK-8010804.js.EXPECTED Changeset: 1c1453863ea8 Author: attila Date: 2013-05-23 12:01 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/1c1453863ea8 8015267: Allow conversion of JS arrays to Java List/Deque Reviewed-by: lagergren, sundar ! make/build.xml ! src/jdk/nashorn/internal/objects/NativeJava.java + src/jdk/nashorn/internal/runtime/ListAdapter.java ! src/jdk/nashorn/internal/runtime/linker/InvokeByName.java ! src/jdk/nashorn/internal/runtime/resources/Messages.properties + test/script/basic/JDK-8015267.js + test/script/basic/JDK-8015267.js.EXPECTED Changeset: f7eb4436410e Author: lagergren Date: 2013-05-23 13:10 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/f7eb4436410e 8012083: Array literal constant folding issue Reviewed-by: attila, jlaskey ! src/jdk/nashorn/internal/codegen/CodeGenerator.java ! src/jdk/nashorn/internal/codegen/FinalizeTypes.java ! src/jdk/nashorn/internal/codegen/FoldConstants.java + test/script/basic/JDK-8012083.js + test/script/basic/JDK-8012083.js.EXPECTED Changeset: 704bc91a0c41 Author: attila Date: 2013-05-23 13:36 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/704bc91a0c41 8015278: Revert accidental changes to build.xml Reviewed-by: jlaskey, lagergren ! make/build.xml Changeset: 8af550dee961 Author: jlaskey Date: 2013-05-23 09:49 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/8af550dee961 Merge Changeset: 6fc7b51e83d6 Author: lagergren Date: 2013-05-23 15:51 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/6fc7b51e83d6 8012522: Clean up lexical contexts - split out stack based functionality in CodeGenerator and generify NodeVisitors based on their LexicalContext type to avoid casts Reviewed-by: attila, jlaskey ! src/jdk/nashorn/internal/codegen/Attr.java ! src/jdk/nashorn/internal/codegen/CodeGenerator.java + src/jdk/nashorn/internal/codegen/CodeGeneratorLexicalContext.java ! src/jdk/nashorn/internal/codegen/CompilationPhase.java ! src/jdk/nashorn/internal/codegen/FinalizeTypes.java ! src/jdk/nashorn/internal/codegen/FoldConstants.java ! src/jdk/nashorn/internal/codegen/Lower.java ! src/jdk/nashorn/internal/codegen/RangeAnalyzer.java ! src/jdk/nashorn/internal/codegen/SharedScopeCall.java ! src/jdk/nashorn/internal/codegen/Splitter.java ! src/jdk/nashorn/internal/codegen/WeighNodes.java ! src/jdk/nashorn/internal/ir/AccessNode.java ! src/jdk/nashorn/internal/ir/BinaryNode.java ! src/jdk/nashorn/internal/ir/Block.java ! src/jdk/nashorn/internal/ir/BreakNode.java ! src/jdk/nashorn/internal/ir/CallNode.java ! src/jdk/nashorn/internal/ir/CaseNode.java ! src/jdk/nashorn/internal/ir/CatchNode.java ! src/jdk/nashorn/internal/ir/ContinueNode.java ! src/jdk/nashorn/internal/ir/EmptyNode.java ! src/jdk/nashorn/internal/ir/ExecuteNode.java ! src/jdk/nashorn/internal/ir/ForNode.java ! src/jdk/nashorn/internal/ir/FunctionNode.java ! src/jdk/nashorn/internal/ir/IdentNode.java ! src/jdk/nashorn/internal/ir/IfNode.java ! src/jdk/nashorn/internal/ir/IndexNode.java ! src/jdk/nashorn/internal/ir/LabelNode.java ! src/jdk/nashorn/internal/ir/LexicalContextNode.java ! src/jdk/nashorn/internal/ir/LiteralNode.java ! src/jdk/nashorn/internal/ir/Node.java ! src/jdk/nashorn/internal/ir/ObjectNode.java ! src/jdk/nashorn/internal/ir/PropertyNode.java ! src/jdk/nashorn/internal/ir/ReturnNode.java ! src/jdk/nashorn/internal/ir/RuntimeNode.java ! src/jdk/nashorn/internal/ir/SplitNode.java ! src/jdk/nashorn/internal/ir/SwitchNode.java ! src/jdk/nashorn/internal/ir/TernaryNode.java ! src/jdk/nashorn/internal/ir/ThrowNode.java ! src/jdk/nashorn/internal/ir/TryNode.java ! src/jdk/nashorn/internal/ir/UnaryNode.java ! src/jdk/nashorn/internal/ir/VarNode.java ! src/jdk/nashorn/internal/ir/WhileNode.java ! src/jdk/nashorn/internal/ir/WithNode.java ! src/jdk/nashorn/internal/ir/debug/JSONWriter.java ! src/jdk/nashorn/internal/ir/debug/PrintVisitor.java ! src/jdk/nashorn/internal/ir/visitor/NodeOperatorVisitor.java ! src/jdk/nashorn/internal/ir/visitor/NodeVisitor.java ! src/jdk/nashorn/internal/objects/ArrayBufferView.java ! src/jdk/nashorn/internal/runtime/DebugLogger.java ! src/jdk/nashorn/internal/runtime/linker/JavaAdapterClassLoader.java ! src/jdk/nashorn/internal/runtime/linker/JavaAdapterFactory.java ! src/jdk/nashorn/internal/runtime/linker/JavaAdapterGeneratorBase.java Changeset: fdfb4edd78d6 Author: hannesw Date: 2013-05-24 13:54 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/fdfb4edd78d6 8011630: JSON parsing performance issue Reviewed-by: lagergren, sundar ! src/jdk/nashorn/internal/objects/NativeArguments.java ! src/jdk/nashorn/internal/runtime/AccessorProperty.java ! src/jdk/nashorn/internal/runtime/FindProperty.java ! src/jdk/nashorn/internal/runtime/Property.java ! src/jdk/nashorn/internal/runtime/ScriptObject.java ! src/jdk/nashorn/internal/runtime/SetMethodCreator.java ! src/jdk/nashorn/internal/runtime/UserAccessorProperty.java Changeset: 4d2eca4d4d66 Author: sundar Date: 2013-05-24 18:39 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/4d2eca4d4d66 8015354: JSON.parse should not use [[Put]] but use [[DefineOwnProperty]] instead Reviewed-by: lagergren, hannesw ! src/jdk/nashorn/internal/objects/NativeFloat32Array.java ! src/jdk/nashorn/internal/objects/NativeFloat64Array.java ! src/jdk/nashorn/internal/objects/NativeInt16Array.java ! src/jdk/nashorn/internal/objects/NativeInt32Array.java ! src/jdk/nashorn/internal/objects/NativeInt8Array.java ! src/jdk/nashorn/internal/objects/NativeUint16Array.java ! src/jdk/nashorn/internal/objects/NativeUint32Array.java ! src/jdk/nashorn/internal/objects/NativeUint8Array.java ! src/jdk/nashorn/internal/objects/NativeUint8ClampedArray.java ! src/jdk/nashorn/internal/runtime/JSONFunctions.java ! src/jdk/nashorn/internal/runtime/Property.java + test/script/basic/JDK-8015354.js Changeset: 751cfefff5eb Author: sundar Date: 2013-05-24 23:27 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/751cfefff5eb 8015351: Nashorn shell does not start with Turkish locale Reviewed-by: jlaskey ! make/project.properties ! src/jdk/nashorn/internal/runtime/options/OptionTemplate.java Changeset: 0bf451c0678d Author: hannesw Date: 2013-05-27 12:26 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/0bf451c0678d 8015348: RegExp("[") results in StackOverflowError Reviewed-by: sundar, attila ! src/jdk/nashorn/internal/runtime/regexp/RegExpScanner.java + test/script/basic/JDK-8015348.js + test/script/basic/JDK-8015348.js.EXPECTED Changeset: 1f57afd14cc1 Author: lagergren Date: 2013-05-27 13:11 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/1f57afd14cc1 8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose Reviewed-by: jlaskey, attila ! make/build-benchmark.xml ! src/jdk/nashorn/internal/runtime/AccessorProperty.java ! src/jdk/nashorn/internal/runtime/Property.java ! src/jdk/nashorn/internal/runtime/UserAccessorProperty.java ! test/script/basic/compile-octane.js.EXPECTED ! test/script/basic/run-octane.js Changeset: 910fd2849c4c Author: lagergren Date: 2013-05-27 13:12 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/910fd2849c4c Merge Changeset: 343fd0450802 Author: sundar Date: 2013-05-27 20:41 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/343fd0450802 8015352: "i".toUpperCase() => currently returns "??", but should be "I" (with Turkish locale) Reviewed-by: jlaskey, lagergren ! src/jdk/nashorn/internal/objects/NativeString.java ! src/jdk/nashorn/internal/runtime/ScriptEnvironment.java ! src/jdk/nashorn/internal/runtime/options/OptionTemplate.java ! src/jdk/nashorn/internal/runtime/options/Options.java ! src/jdk/nashorn/internal/runtime/resources/Options.properties + test/script/basic/JDK-8015352.js Changeset: e6193dcfe36c Author: lagergren Date: 2013-05-27 17:57 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/e6193dcfe36c 8015447: Octane harness fixes for rhino and entire test runs: ant octane, ant octane-v8, ant octane-rhino Reviewed-by: sundar, jlaskey ! make/build-benchmark.xml ! test/script/basic/run-octane.js Changeset: d56168970de1 Author: sundar Date: 2013-05-28 16:37 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/d56168970de1 8015459: Octane test run fails on Turkish locale Reviewed-by: lagergren, attila ! src/jdk/nashorn/internal/codegen/CodeGenerator.java ! src/jdk/nashorn/internal/objects/DateParser.java ! src/jdk/nashorn/internal/parser/TokenType.java ! src/jdk/nashorn/internal/runtime/GlobalFunctions.java ! src/jdk/nashorn/internal/runtime/JSType.java ! src/jdk/nashorn/internal/runtime/Logging.java ! src/jdk/nashorn/internal/runtime/ScriptRuntime.java ! src/jdk/nashorn/internal/runtime/options/OptionTemplate.java Changeset: f472f7046ec9 Author: sundar Date: 2013-05-29 15:41 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/f472f7046ec9 8005979: A lot of tests are named "runTest" in reports Reviewed-by: jlaskey ! make/project.properties Changeset: f69e76417211 Author: lagergren Date: 2013-05-29 14:08 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/f69e76417211 8011023: Math round didn't conform to ECMAScript 5 spec Reviewed-by: jlaskey, attila ! src/jdk/nashorn/internal/objects/NativeMath.java + test/script/basic/JDK-8011023.js + test/script/basic/JDK-8011023.js.EXPECTED Changeset: a2e2797392b3 Author: sundar Date: 2013-05-29 21:27 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/a2e2797392b3 8015349: "abc".lastIndexOf("a",-1) should evaluate to 0 and not -1 Reviewed-by: lagergren, attila, jlaskey ! src/jdk/nashorn/internal/objects/NativeString.java + test/script/basic/JDK-8015349.js + test/script/basic/JDK-8015349.js.EXPECTED Changeset: 4463e94d9b0d Author: lana Date: 2013-05-29 16:59 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/4463e94d9b0d Merge - src/jdk/nashorn/internal/runtime/options/ValueOption.java - src/jdk/nashorn/internal/runtime/regexp/DefaultRegExp.java - src/jdk/nashorn/internal/runtime/regexp/joni/AsmCompiler.java - src/jdk/nashorn/internal/runtime/regexp/joni/AsmCompilerSupport.java - src/jdk/nashorn/internal/runtime/regexp/joni/CaptureTreeNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/NameEntry.java - src/jdk/nashorn/internal/runtime/regexp/joni/NativeMachine.java - src/jdk/nashorn/internal/runtime/regexp/joni/UnsetAddrList.java - src/jdk/nashorn/internal/runtime/regexp/joni/ast/CTypeNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/ast/CallNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/AbstractBench.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchGreedyBacktrack.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchRailsRegs.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchSeveralRegexps.java - src/jdk/nashorn/internal/runtime/regexp/joni/constants/Reduce.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/AsciiTables.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/PosixBracket.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/Ptr.java - src/netscape/javascript/JSObject.java Changeset: ddbf41575a2b Author: lana Date: 2013-06-03 23:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/ddbf41575a2b Merge - src/jdk/nashorn/internal/runtime/options/ValueOption.java - src/jdk/nashorn/internal/runtime/regexp/DefaultRegExp.java - src/jdk/nashorn/internal/runtime/regexp/joni/AsmCompiler.java - src/jdk/nashorn/internal/runtime/regexp/joni/AsmCompilerSupport.java - src/jdk/nashorn/internal/runtime/regexp/joni/CaptureTreeNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/NameEntry.java - src/jdk/nashorn/internal/runtime/regexp/joni/NativeMachine.java - src/jdk/nashorn/internal/runtime/regexp/joni/UnsetAddrList.java - src/jdk/nashorn/internal/runtime/regexp/joni/ast/CTypeNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/ast/CallNode.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/AbstractBench.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchGreedyBacktrack.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchRailsRegs.java - src/jdk/nashorn/internal/runtime/regexp/joni/bench/BenchSeveralRegexps.java - src/jdk/nashorn/internal/runtime/regexp/joni/constants/Reduce.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/AsciiTables.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/PosixBracket.java - src/jdk/nashorn/internal/runtime/regexp/joni/encoding/Ptr.java - src/netscape/javascript/JSObject.java Changeset: e169ab024d26 Author: mduigou Date: 2013-06-05 13:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/e169ab024d26 Merge - .jcheck/conf From mike.duigou at oracle.com Wed Jun 5 15:21:31 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 05 Jun 2013 22:21:31 +0000 Subject: hg: lambda/lambda/jaxp: 8 new changesets Message-ID: <20130605222224.3297948FCB@hg.openjdk.java.net> Changeset: 1ab5d8d6eab8 Author: katleman Date: 2013-05-29 10:15 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/1ab5d8d6eab8 8015525: JDK8 b91 source with GPL header errors Reviewed-by: dholmes, lancea ! src/com/sun/org/apache/xerces/internal/impl/XMLEntityManager.java Changeset: a6596a06e10b Author: katleman Date: 2013-05-30 10:58 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/a6596a06e10b Added tag jdk8-b92 for changeset 1ab5d8d6eab8 ! .hgtags Changeset: a7cec93e4682 Author: joehw Date: 2013-05-20 16:11 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/a7cec93e4682 8014891: Redundant setting of external access properties in setFeatures Reviewed-by: lancea ! src/com/sun/org/apache/xerces/internal/jaxp/DocumentBuilderImpl.java ! src/com/sun/org/apache/xerces/internal/jaxp/SAXParserImpl.java Changeset: 37b73984640a Author: joehw Date: 2013-05-20 23:46 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/37b73984640a 8012683: Remove unused, obsolete ObjectFactory classes Reviewed-by: lancea - src/com/sun/org/apache/xerces/internal/xinclude/ObjectFactory.java - src/com/sun/org/apache/xml/internal/serialize/ObjectFactory.java Changeset: 0765806dcc58 Author: lana Date: 2013-05-22 09:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/0765806dcc58 Merge Changeset: 627c265d6e0c Author: lana Date: 2013-05-29 16:57 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/627c265d6e0c Merge - src/com/sun/org/apache/xerces/internal/xinclude/ObjectFactory.java - src/com/sun/org/apache/xml/internal/serialize/ObjectFactory.java Changeset: d583a491d63c Author: lana Date: 2013-06-03 23:19 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/d583a491d63c Merge - src/com/sun/org/apache/xerces/internal/xinclude/ObjectFactory.java - src/com/sun/org/apache/xml/internal/serialize/ObjectFactory.java Changeset: a924a783e976 Author: mduigou Date: 2013-06-05 13:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/a924a783e976 Merge ! .hgtags - .jcheck/conf From mike.duigou at oracle.com Wed Jun 5 15:21:31 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 05 Jun 2013 22:21:31 +0000 Subject: hg: lambda/lambda/hotspot: 42 new changesets Message-ID: <20130605222456.8A37B48FCD@hg.openjdk.java.net> Changeset: 7ec426e29e4c Author: amurillo Date: 2013-05-17 09:10 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/7ec426e29e4c 8014760: new hotspot build - hs25-b34 Reviewed-by: jcoomes ! make/hotspot_version Changeset: f49e0508a38a Author: rbackman Date: 2013-05-15 11:30 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/f49e0508a38a 4965252: JvmtiExport::post_raw_field_modification jni ref handling is odd Reviewed-by: coleenp, sspitsyn ! src/share/vm/prims/jvmtiExport.cpp Changeset: 243469d929e6 Author: ctornqvi Date: 2013-05-16 15:31 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/243469d929e6 8008169: test/runtime/7158804/Test7158804.sh has bad copyright header Summary: Re-wrote test in Java in addition to fixing the Copyright notice. Also reviewed by leonid.mesnik at oracle.com Reviewed-by: coleenp, ctornqvi Contributed-by: Mikhailo Seledtsov - test/runtime/7158804/Test7158804.sh + test/runtime/CommandLine/ConfigFileParsing.java Changeset: 17db82f22f1e Author: ctornqvi Date: 2013-05-16 17:54 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/17db82f22f1e 8014511: runtime/RedefineObject/TestRedefineObject.java has incorrect classname in @run tag Summary: Corrected the class name Reviewed-by: coleenp, ctornqvi, hseigel Contributed-by: Mikhailo Seledtsov ! test/runtime/RedefineObject/TestRedefineObject.java Changeset: 78332b46e604 Author: kevinw Date: 2013-05-16 12:40 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/78332b46e604 6313816: SA: jstack -m fails on Win32 : UnalignedAddressException Reviewed-by: sla, poonam - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java ! agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgCDebugger.java + agent/src/share/classes/sun/jvm/hotspot/debugger/windows/amd64/WindowsAMD64CFrame.java + agent/src/share/classes/sun/jvm/hotspot/debugger/windows/x86/WindowsX86CFrame.java ! make/sa.files Changeset: 205dd30230e1 Author: shade Date: 2013-05-17 01:43 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/205dd30230e1 8012939: @Contended doesn't work correctly with inheritance Summary: Fix instance_size miscalculation. Reviewed-by: jrose, kvn ! src/share/vm/classfile/classFileParser.cpp + test/runtime/contended/Inheritance1.java Changeset: b334821dad92 Author: dholmes Date: 2013-05-16 21:19 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/b334821dad92 Merge Changeset: 50e9396d5257 Author: shade Date: 2013-05-17 01:58 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/50e9396d5257 8014509: @Contended: explicit default value behaves differently from the implicit value Summary: Treat the empty string as the default value tag Reviewed-by: kvn, twisti ! src/share/vm/classfile/classFileParser.cpp + test/runtime/contended/DefaultValue.java Changeset: 074ba6269cf4 Author: dholmes Date: 2013-05-16 22:11 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/074ba6269cf4 Merge - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java Changeset: 1ba508fcd3e2 Author: dholmes Date: 2013-05-16 23:40 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/1ba508fcd3e2 Merge Changeset: 6ce351ac7339 Author: rdurbin Date: 2013-05-17 08:51 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/6ce351ac7339 7145527: sscanf must use a length in the format string Summary: Remove dead code containing last call to scanf with no string length specifier Reviewed-by: dcubed, coleenp ! src/share/vm/utilities/debug.cpp Changeset: a250c89cf9e3 Author: dcubed Date: 2013-05-17 08:56 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/a250c89cf9e3 Merge Changeset: b5be63340698 Author: dcubed Date: 2013-05-17 11:36 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/b5be63340698 Merge - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java ! src/share/vm/classfile/classFileParser.cpp - test/runtime/7158804/Test7158804.sh Changeset: 386b77bf6427 Author: dcubed Date: 2013-05-17 17:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/386b77bf6427 Merge - make/bsd/makefiles/launcher.make - make/linux/makefiles/launcher.make - make/solaris/makefiles/launcher.make - make/windows/makefiles/launcher.make - src/os/posix/launcher/java_md.c - src/os/posix/launcher/java_md.h - src/os/posix/launcher/launcher.script - src/os/windows/launcher/java_md.c - src/os/windows/launcher/java_md.h - src/share/tools/launcher/java.c - src/share/tools/launcher/java.h - src/share/tools/launcher/jli_util.c - src/share/tools/launcher/jli_util.h - src/share/tools/launcher/wildcard.c - src/share/tools/launcher/wildcard.h - src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.inline.hpp Changeset: a5d6f0c3585f Author: iklam Date: 2013-05-18 20:41 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/a5d6f0c3585f 8014262: PrintStringTableStatistics should include more footprint info Summary: Added info for the string/symbol objects and the hash entries Reviewed-by: coleenp, rbackman ! src/share/vm/classfile/symbolTable.cpp ! src/share/vm/utilities/hashtable.cpp ! src/share/vm/utilities/hashtable.hpp Changeset: 5e3573e08a83 Author: shade Date: 2013-05-20 15:43 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/5e3573e08a83 8014871: Move @Contended regression tests to the same place Summary: Move the missing test to appropriate location. Reviewed-by: dholmes, sla - test/runtime/8003985/Test8003985.java + test/runtime/contended/Basic.java Changeset: bbddfb08190f Author: shade Date: 2013-05-20 23:41 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/bbddfb08190f 8014878: Clean up class field layout code Summary: rename/remove local variables, re-arrange instance_size calculation, more comments. Reviewed-by: kvn, coleenp ! src/share/vm/classfile/classFileParser.cpp Changeset: 293b99787401 Author: dholmes Date: 2013-05-14 07:24 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/293b99787401 8014460: Need to check for non-empty EXT_LIBS_PATH before using it Reviewed-by: tbell, collins, sla, coleenp ! make/bsd/makefiles/arm.make ! make/linux/makefiles/arm.make Changeset: 26579ac80ce9 Author: bpittore Date: 2013-05-15 23:06 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/26579ac80ce9 8014669: arch specific flags not passed to some link commands Summary: EXTRA_CFLAGS does not propagate to saproc and jsig makefiles Reviewed-by: dholmes, tbell, collins ! make/linux/makefiles/jsig.make ! make/linux/makefiles/saproc.make Changeset: f8c833eb2a5f Author: jiangli Date: 2013-05-20 13:13 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/f8c833eb2a5f Merge Changeset: c838b672691c Author: jiangli Date: 2013-05-23 13:40 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/c838b672691c Merge Changeset: 91eba9f82325 Author: anoll Date: 2013-05-16 15:46 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/91eba9f82325 8012371: Adjust Tiered compile threshold according to available space in code cache Summary: Added command line parameter to define a threshold at which C1 compilation threshold for is increased. Reviewed-by: kvn, iveresov ! src/share/vm/code/codeCache.cpp ! src/share/vm/code/codeCache.hpp ! src/share/vm/runtime/advancedThresholdPolicy.cpp ! src/share/vm/runtime/advancedThresholdPolicy.hpp ! src/share/vm/runtime/arguments.cpp ! src/share/vm/runtime/globals.hpp Changeset: ec922e5c545a Author: anoll Date: 2013-05-22 10:28 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/ec922e5c545a 8012312: hsdis fails to compile with binutils-2.23.2 Summary: added to header file to make hsdis compile with binutils 2.23.* Reviewed-by: kvn, twisti ! src/share/tools/hsdis/hsdis.c Changeset: b4907b24ed48 Author: twisti Date: 2013-05-22 11:44 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/b4907b24ed48 Merge Changeset: 1682bec79205 Author: kvn Date: 2013-05-22 09:02 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/1682bec79205 8014811: loopTransform.cpp assert(cmp_end->in(2) == limit) failed Summary: Stop current iteration of loop opts if partial_peel() failed and it created node clones outside processed loop. Reviewed-by: roland ! src/share/vm/opto/loopnode.hpp ! src/share/vm/opto/loopopts.cpp Changeset: 71a2d06b9c2b Author: kvn Date: 2013-05-22 17:39 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/71a2d06b9c2b Merge Changeset: 3f281b313240 Author: kvn Date: 2013-05-22 18:25 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/3f281b313240 8010927: Kitchensink crashed with SIGSEGV, Problematic frame: v ~StubRoutines::checkcast_arraycopy Summary: Changed gen_write_ref_array_post_barrier() code on x64 to pass start address and number of copied oop elements. In generate_checkcast_copy() skip post barrier code if no elements are copied. Reviewed-by: roland ! src/cpu/x86/vm/stubGenerator_x86_32.cpp ! src/cpu/x86/vm/stubGenerator_x86_64.cpp + test/compiler/8010927/Test8010927.java Changeset: 01e51113b4f5 Author: anoll Date: 2013-05-23 14:11 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/01e51113b4f5 8014430: JRE crashes instead of stop compilation on full Code Cache. Internal Error (c1_Compiler.cpp:87) Summary: Disable client compiler and switch to interpreter if there is not enough free space in the code cache. Reviewed-by: kvn, twisti ! src/share/vm/c1/c1_Compiler.cpp ! src/share/vm/c1/c1_Compiler.hpp Changeset: 59e18b573605 Author: twisti Date: 2013-05-23 15:30 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/59e18b573605 Merge Changeset: 001ec9515f84 Author: ehelin Date: 2013-05-17 11:57 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/001ec9515f84 8014277: Remove ObjectClosure as base class for BoolObjectClosure Reviewed-by: brutisso, tschatzl ! src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp ! src/share/vm/gc_implementation/g1/concurrentMark.hpp ! src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp ! src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp ! src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp ! src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp ! src/share/vm/gc_implementation/shared/markSweep.cpp ! src/share/vm/gc_implementation/shared/markSweep.hpp ! src/share/vm/memory/defNewGeneration.cpp ! src/share/vm/memory/defNewGeneration.hpp ! src/share/vm/memory/iterator.hpp ! src/share/vm/memory/referenceProcessor.cpp ! src/share/vm/memory/sharedHeap.cpp ! src/share/vm/runtime/jniHandles.cpp Changeset: 2138a2c14831 Author: jwilhelm Date: 2013-05-19 20:31 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/2138a2c14831 Merge ! src/share/vm/gc_implementation/shared/markSweep.cpp Changeset: 10f759898d40 Author: tamao Date: 2013-05-20 10:44 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/10f759898d40 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap Summary: Print helpful error message when VM aborts due to inability of allocating bit maps or card tables Reviewed-by: jmasa, stefank Contributed-by: tamao ! src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.cpp ! src/share/vm/gc_implementation/parallelScavenge/parMarkBitMap.hpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Changeset: 2b1a9d972fc2 Author: jmasa Date: 2013-05-20 22:34 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType Reviewed-by: ehelin, stefank ! src/share/vm/memory/metaspace.cpp ! src/share/vm/memory/metaspace.hpp Changeset: 28e53b8db94f Author: brutisso Date: 2013-05-21 08:50 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/28e53b8db94f 7066063: CMS: "Conservation Principle" assert failed Summary: Add call to coalBirth() in CompactibleFreeListSpace::reset() Reviewed-by: ysr, jmasa ! src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp Changeset: 5ed122fbd0ef Author: brutisso Date: 2013-05-21 10:39 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/5ed122fbd0ef Merge Changeset: 6702da6b6082 Author: tschatzl Date: 2013-05-21 11:30 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/6702da6b6082 8014405: G1: PerRegionTable::fl_mem_size() calculates size of the free list using wrong element sizes Summary: Instead of using a simple sizeof(), ask the PerRegionTable class about its size when iterating over the free list. Reviewed-by: jwilhelm, brutisso ! src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp ! src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp ! src/share/vm/prims/jni.cpp Changeset: 7c5a1b62f53d Author: brutisso Date: 2013-05-22 08:04 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/7c5a1b62f53d 8014971: Minor code cleanup of the freelist management Reviewed-by: jwilhelm, jmasa, tschatzl ! src/share/vm/gc_implementation/concurrentMarkSweep/adaptiveFreeList.cpp ! src/share/vm/gc_implementation/concurrentMarkSweep/adaptiveFreeList.hpp ! src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp ! src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp ! src/share/vm/memory/freeList.cpp ! src/share/vm/memory/freeList.hpp Changeset: 62890ed7e2a8 Author: jwilhelm Date: 2013-05-24 09:29 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/62890ed7e2a8 Merge - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java - test/runtime/7158804/Test7158804.sh - test/runtime/8003985/Test8003985.java Changeset: 38da9f4f6709 Author: amurillo Date: 2013-05-24 09:25 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/38da9f4f6709 Merge - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/amd64/AMD64CFrame.java - agent/src/share/classes/sun/jvm/hotspot/debugger/cdbg/basic/x86/X86CFrame.java - test/runtime/7158804/Test7158804.sh - test/runtime/8003985/Test8003985.java Changeset: 092018493d3b Author: amurillo Date: 2013-05-24 09:25 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/092018493d3b Added tag hs25-b34 for changeset 38da9f4f6709 ! .hgtags Changeset: 573d86d412cd Author: katleman Date: 2013-05-30 10:57 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/573d86d412cd Added tag jdk8-b92 for changeset 092018493d3b ! .hgtags Changeset: 2ec664fe8e21 Author: mduigou Date: 2013-06-05 13:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/2ec664fe8e21 Merge ! .hgtags - .jcheck/conf ! src/share/vm/classfile/classFileParser.cpp ! src/share/vm/runtime/globals.hpp From mike.duigou at oracle.com Wed Jun 5 15:21:38 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 05 Jun 2013 22:21:38 +0000 Subject: hg: lambda/lambda/jdk: 64 new changesets Message-ID: <20130605224445.29D3548FD0@hg.openjdk.java.net> Changeset: a2a2a91075ad Author: katleman Date: 2013-05-29 10:16 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a2a2a91075ad 8015525: JDK8 b91 source with GPL header errors Reviewed-by: dholmes, lancea ! test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/MapTest.java ! test/jdk/lambda/MethodReferenceTestInstanceMethod.java ! test/jdk/lambda/MethodReferenceTestKinds.java ! test/jdk/lambda/MethodReferenceTestSueCase1.java ! test/jdk/lambda/MethodReferenceTestSueCase2.java ! test/jdk/lambda/MethodReferenceTestSueCase4.java ! test/jdk/lambda/separate/AttributeInjector.java ! test/jdk/lambda/separate/ClassFile.java ! test/jdk/lambda/separate/ClassFilePreprocessor.java ! test/jdk/lambda/separate/ClassToInterfaceConverter.java ! test/jdk/lambda/separate/Compiler.java ! test/jdk/lambda/separate/DirectedClassLoader.java ! test/jdk/lambda/separate/SourceModel.java ! test/jdk/lambda/separate/TestHarness.java ! test/jdk/lambda/vm/DefaultMethodRegressionTests.java ! test/jdk/lambda/vm/DefaultMethodsTest.java ! test/jdk/lambda/vm/InterfaceAccessFlagsTest.java Changeset: 3c08c9ebd1fb Author: katleman Date: 2013-05-30 10:58 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/3c08c9ebd1fb Added tag jdk8-b92 for changeset a2a2a91075ad ! .hgtags Changeset: 93de1ab38793 Author: jchen Date: 2013-05-17 10:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/93de1ab38793 8003444: Fix potential NULL pointer dereference Reviewed-by: jgodinez, prr ! src/share/native/sun/java2d/cmm/lcms/cmscgats.c ! src/share/native/sun/java2d/cmm/lcms/cmslut.c Changeset: 0cec8dc2bcf8 Author: lana Date: 2013-05-22 19:35 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0cec8dc2bcf8 Merge - make/com/sun/script/Makefile - make/sun/org/Makefile - make/sun/org/mozilla/Makefile - make/sun/org/mozilla/javascript/Makefile - src/share/classes/com/sun/script/javascript/ExternalScriptable.java - src/share/classes/com/sun/script/javascript/JSAdapter.java - src/share/classes/com/sun/script/javascript/JavaAdapter.java - src/share/classes/com/sun/script/javascript/META-INF/services/javax.script.ScriptEngineFactory - src/share/classes/com/sun/script/javascript/RhinoClassShutter.java - src/share/classes/com/sun/script/javascript/RhinoCompiledScript.java - src/share/classes/com/sun/script/javascript/RhinoScriptEngine.java - src/share/classes/com/sun/script/javascript/RhinoScriptEngineFactory.java - src/share/classes/com/sun/script/javascript/RhinoTopLevel.java - src/share/classes/com/sun/script/javascript/RhinoWrapFactory.java - src/share/classes/com/sun/script/util/BindingsBase.java - src/share/classes/com/sun/script/util/BindingsEntrySet.java - src/share/classes/com/sun/script/util/BindingsImpl.java - src/share/classes/com/sun/script/util/InterfaceImplementor.java - src/share/classes/com/sun/script/util/ScriptEngineFactoryBase.java - src/share/classes/java/time/format/DateTimeFormatSymbols.java - src/share/classes/sun/nio/cs/ext/META-INF/services/java.nio.charset.spi.CharsetProvider - test/java/lang/Thread/StackTraces.java - test/java/time/tck/java/time/format/TCKDateTimeFormatSymbols.java - test/java/time/test/java/time/format/TestDateTimeFormatSymbols.java - test/java/util/logging/bundlesearch/LoadItUp.java - test/sun/security/provider/certpath/X509CertPath/ForwardBuildCompromised.java - test/sun/security/provider/certpath/X509CertPath/ReverseBuildCompromised.java - test/sun/security/provider/certpath/X509CertPath/ValidateCompromised.java Changeset: 0208f5f12dc3 Author: jchen Date: 2013-05-23 12:16 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0208f5f12dc3 8012629: java.lang.UnsatisfiedLinkError exception throw by getAllFonts() on MacOSX Reviewed-by: bae, prr ! make/sun/awt/FILES_c_unix.gmk ! make/sun/awt/FILES_export_unix.gmk ! make/sun/awt/mawt.gmk ! makefiles/CompileNativeLibraries.gmk ! src/macosx/native/sun/font/AWTFont.m Changeset: f24f9038e050 Author: prr Date: 2013-05-24 09:31 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f24f9038e050 8008535: JDK7 Printing : CJK and Latin Text in a string overlap Reviewed-by: bae, jgodinez ! src/windows/classes/sun/awt/windows/WPathGraphics.java + test/java/awt/print/PrinterJob/PrintLatinCJKTest.java Changeset: f4ad2fa22474 Author: jgodinez Date: 2013-05-29 09:18 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f4ad2fa22474 7183520: [macosx]Unable to print out the defined page for 2D_PrintingTiger/JTablePrintPageRangesTest. Reviewed-by: bae, prr ! src/macosx/classes/sun/lwawt/macosx/CPrinterJob.java Changeset: 7e2a887a069e Author: jgodinez Date: 2013-05-29 09:46 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/7e2a887a069e 8012381: [macosx]Unable to print out the defined page for 2D_PrintingTiger/JTablePrintPageRangesTest Reviewed-by: jchen, prr ! src/solaris/classes/sun/print/IPPPrintService.java ! test/java/awt/print/PrinterJob/Collate2DPrintingTest.java Changeset: 8ac29ee867fd Author: lana Date: 2013-05-29 16:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8ac29ee867fd Merge Changeset: 85df65495177 Author: mcherkas Date: 2013-05-21 03:20 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/85df65495177 7011777: JDK 6 parses html text with script tags within comments differently from previous releases Reviewed-by: alexsch Contributed-by: Dmitry Markov ! src/share/classes/javax/swing/text/html/parser/Parser.java + test/javax/swing/text/html/parser/Parser/7011777/bug7011777.java Changeset: e36d0b9ed018 Author: alitvinov Date: 2013-05-21 05:02 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e36d0b9ed018 8005607: Recursion in J2DXErrHandler() Causes a Stack Overflow on Linux Reviewed-by: art, anthony, prr ! src/solaris/classes/sun/awt/X11/MotifDnDConstants.java ! src/solaris/classes/sun/awt/X11/MotifDnDDropTargetProtocol.java ! src/solaris/classes/sun/awt/X11/WindowPropertyGetter.java ! src/solaris/classes/sun/awt/X11/XConstants.java ! src/solaris/classes/sun/awt/X11/XDnDDragSourceProtocol.java ! src/solaris/classes/sun/awt/X11/XDnDDropTargetProtocol.java ! src/solaris/classes/sun/awt/X11/XDragSourceProtocol.java ! src/solaris/classes/sun/awt/X11/XDropTargetRegistry.java ! src/solaris/classes/sun/awt/X11/XEmbedCanvasPeer.java ! src/solaris/classes/sun/awt/X11/XErrorHandler.java + src/solaris/classes/sun/awt/X11/XErrorHandlerUtil.java ! src/solaris/classes/sun/awt/X11/XQueryTree.java ! src/solaris/classes/sun/awt/X11/XToolkit.java ! src/solaris/classes/sun/awt/X11/XTranslateCoordinates.java ! src/solaris/classes/sun/awt/X11/XWM.java ! src/solaris/classes/sun/awt/X11/XlibUtil.java ! src/solaris/classes/sun/awt/X11/generator/WrapperGenerator.java ! src/solaris/native/sun/awt/awt_GraphicsEnv.c ! src/solaris/native/sun/awt/awt_GraphicsEnv.h ! src/solaris/native/sun/awt/awt_util.c ! src/solaris/native/sun/awt/awt_util.h ! src/solaris/native/sun/java2d/opengl/GLXSurfaceData.c ! src/solaris/native/sun/java2d/x11/X11SurfaceData.c ! src/solaris/native/sun/xawt/XlibWrapper.c Changeset: 73d3bed5f8c8 Author: lana Date: 2013-05-22 17:37 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/73d3bed5f8c8 Merge - make/com/sun/script/Makefile - make/sun/org/Makefile - make/sun/org/mozilla/Makefile - make/sun/org/mozilla/javascript/Makefile - src/share/classes/com/sun/script/javascript/ExternalScriptable.java - src/share/classes/com/sun/script/javascript/JSAdapter.java - src/share/classes/com/sun/script/javascript/JavaAdapter.java - src/share/classes/com/sun/script/javascript/META-INF/services/javax.script.ScriptEngineFactory - src/share/classes/com/sun/script/javascript/RhinoClassShutter.java - src/share/classes/com/sun/script/javascript/RhinoCompiledScript.java - src/share/classes/com/sun/script/javascript/RhinoScriptEngine.java - src/share/classes/com/sun/script/javascript/RhinoScriptEngineFactory.java - src/share/classes/com/sun/script/javascript/RhinoTopLevel.java - src/share/classes/com/sun/script/javascript/RhinoWrapFactory.java - src/share/classes/com/sun/script/util/BindingsBase.java - src/share/classes/com/sun/script/util/BindingsEntrySet.java - src/share/classes/com/sun/script/util/BindingsImpl.java - src/share/classes/com/sun/script/util/InterfaceImplementor.java - src/share/classes/com/sun/script/util/ScriptEngineFactoryBase.java - src/share/classes/java/time/format/DateTimeFormatSymbols.java - src/share/classes/sun/nio/cs/ext/META-INF/services/java.nio.charset.spi.CharsetProvider - test/java/lang/Thread/StackTraces.java - test/java/time/tck/java/time/format/TCKDateTimeFormatSymbols.java - test/java/time/test/java/time/format/TestDateTimeFormatSymbols.java - test/java/util/logging/bundlesearch/LoadItUp.java - test/sun/security/provider/certpath/X509CertPath/ForwardBuildCompromised.java - test/sun/security/provider/certpath/X509CertPath/ReverseBuildCompromised.java - test/sun/security/provider/certpath/X509CertPath/ValidateCompromised.java Changeset: 6261e94e9869 Author: alexsch Date: 2013-05-23 15:52 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6261e94e9869 8014924: JToolTip#setTipText() sometimes (very often) not repaints component. Reviewed-by: serb ! src/share/classes/javax/swing/JToolTip.java Changeset: e8cacde33d27 Author: ant Date: 2013-05-24 18:01 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e8cacde33d27 8013437: Test sun/awt/datatransfer/SuplementaryCharactersTransferTest.java fails to compile since 8b86 Reviewed-by: alexsch ! test/sun/awt/datatransfer/SuplementaryCharactersTransferTest.java Changeset: 6b29c27d0807 Author: malenkov Date: 2013-05-24 19:41 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6b29c27d0807 8013416: Java Bean Persistence with XMLEncoder Reviewed-by: alexsch ! src/share/classes/com/sun/beans/finder/AbstractFinder.java ! src/share/classes/com/sun/beans/finder/ConstructorFinder.java ! src/share/classes/com/sun/beans/finder/MethodFinder.java + test/java/beans/XMLEncoder/Test8013416.java Changeset: c36626831f07 Author: vkarnauk Date: 2013-05-27 12:47 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c36626831f07 8010721: [macosx] In JDK7 the menu bar disappears when a Dialog is shown Reviewed-by: anthony, serb ! src/macosx/classes/sun/lwawt/macosx/CPlatformWindow.java ! src/macosx/native/sun/awt/AWTWindow.m Changeset: 70ac1bf74865 Author: serb Date: 2013-05-27 22:31 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/70ac1bf74865 8014726: TEST_BUG: java/awt/WMSpecificTests/Metacity/FullscreenDialogModality.java should be modified Reviewed-by: serb, anthony Contributed-by: alexander.zvegintsev at oracle.com ! test/java/awt/WMSpecificTests/Metacity/FullscreenDialogModality.java Changeset: ff1c2e379f27 Author: pchelko Date: 2013-05-28 12:37 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/ff1c2e379f27 8000422: [macosx] Views keep scrolling back to the drag position after DnD Reviewed-by: serb, anthony ! src/macosx/classes/sun/lwawt/macosx/CDropTargetContextPeer.java Changeset: 4f24a4f65a07 Author: anthony Date: 2013-05-28 16:38 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/4f24a4f65a07 7039616: java/awt/Window/TranslucentJAppletTest/TranslucentJAppletTest.java should be updated Summary: Consider the test passed if the system does not support translucency Reviewed-by: art ! test/java/awt/Window/TranslucentJAppletTest/TranslucentJAppletTest.java Changeset: 1f0628078531 Author: pchelko Date: 2013-05-29 12:10 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/1f0628078531 8009911: [macosx] SWT app freeze when going full screen using Java 7 on Mac Reviewed-by: anthony, ksrini ! src/macosx/bin/java_md_macosx.c Changeset: c8a0abc1fd2d Author: mcherkas Date: 2013-05-29 18:40 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c8a0abc1fd2d 8014863: Line break calculations in Java 7 are incorrect. Reviewed-by: alexp, alexsch Contributed-by: Dmitry Markov ! src/share/classes/javax/swing/text/View.java + test/javax/swing/text/View/8014863/bug8014863.java Changeset: aae7b96a350e Author: lana Date: 2013-05-29 16:56 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/aae7b96a350e Merge Changeset: 3b1450ee2bb9 Author: dxu Date: 2013-05-17 12:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/3b1450ee2bb9 8011136: FileInputStream.available and skip inconsistencies Summary: Correct the behavior of available() and update related java specs for available() and skip() in InputStream and FileInputStream classes. Reviewed-by: alanb ! src/share/classes/java/io/FileInputStream.java ! src/share/classes/java/io/InputStream.java ! src/share/native/java/io/FileInputStream.c ! test/java/io/FileInputStream/LargeFileAvailable.java ! test/java/io/FileInputStream/NegativeAvailable.java Changeset: 0f7aaabed25f Author: weijun Date: 2013-05-18 10:15 +0800 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0f7aaabed25f 8012261: update policytool to support java.net.HttpURLPermission Reviewed-by: mullan ! src/share/classes/sun/security/tools/policytool/PolicyTool.java ! src/share/classes/sun/security/tools/policytool/Resources.java Changeset: e8b40b034fcd Author: psandoz Date: 2013-05-15 10:15 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e8b40b034fcd 8013334: Spliterator behavior for LinkedList contradicts Spliterator.trySplit Summary: this changeset also contains some minor, non spec, related fixes to tidy up other areas of the JavaDoc. Reviewed-by: plevart, darcy Contributed-by: John Rose , Mike Duigou , Paul Sandoz ! src/share/classes/java/util/Spliterator.java Changeset: 6bbc2816d936 Author: psandoz Date: 2013-05-15 10:25 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6bbc2816d936 8014133: Spliterator.OfPrimitive Reviewed-by: mduigou, forax Contributed-by: Paul Sandoz , Brian Goetz ! src/share/classes/java/util/Spliterator.java Changeset: dc5cf74c8c9c Author: mduigou Date: 2013-05-17 10:36 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/dc5cf74c8c9c 8004015: Additional static and instance utils for functional interfaces. 8011010: Spec j.u.f.Predicate doesn't specify NPEs thrown by the SE8's Reference Implementation Reviewed-by: briangoetz, dholmes, chegar ! src/share/classes/java/util/function/BiConsumer.java ! src/share/classes/java/util/function/BiFunction.java ! src/share/classes/java/util/function/BiPredicate.java ! src/share/classes/java/util/function/BooleanSupplier.java ! src/share/classes/java/util/function/Consumer.java ! src/share/classes/java/util/function/DoubleBinaryOperator.java ! src/share/classes/java/util/function/DoubleConsumer.java ! src/share/classes/java/util/function/DoubleFunction.java ! src/share/classes/java/util/function/DoublePredicate.java ! src/share/classes/java/util/function/DoubleSupplier.java ! src/share/classes/java/util/function/DoubleUnaryOperator.java ! src/share/classes/java/util/function/Function.java ! src/share/classes/java/util/function/IntBinaryOperator.java ! src/share/classes/java/util/function/IntConsumer.java ! src/share/classes/java/util/function/IntFunction.java ! src/share/classes/java/util/function/IntPredicate.java ! src/share/classes/java/util/function/IntSupplier.java ! src/share/classes/java/util/function/IntUnaryOperator.java ! src/share/classes/java/util/function/LongBinaryOperator.java ! src/share/classes/java/util/function/LongConsumer.java ! src/share/classes/java/util/function/LongFunction.java ! src/share/classes/java/util/function/LongPredicate.java ! src/share/classes/java/util/function/LongSupplier.java ! src/share/classes/java/util/function/LongUnaryOperator.java ! src/share/classes/java/util/function/ObjDoubleConsumer.java ! src/share/classes/java/util/function/ObjIntConsumer.java ! src/share/classes/java/util/function/ObjLongConsumer.java ! src/share/classes/java/util/function/Predicate.java ! src/share/classes/java/util/function/Supplier.java ! src/share/classes/java/util/function/ToDoubleBiFunction.java ! src/share/classes/java/util/function/ToDoubleFunction.java ! src/share/classes/java/util/function/ToIntBiFunction.java ! src/share/classes/java/util/function/ToIntFunction.java ! src/share/classes/java/util/function/ToLongBiFunction.java ! src/share/classes/java/util/function/ToLongFunction.java ! src/share/classes/java/util/function/UnaryOperator.java Changeset: 23e75751554a Author: henryjen Date: 2013-05-09 14:44 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/23e75751554a 8006884: (fs) Add Files.list, lines and find Reviewed-by: briangoetz, mduigou Contributed-by: alan.bateman at oracle.com, henry.jen at oracle.com + src/share/classes/java/nio/file/FileTreeIterator.java ! src/share/classes/java/nio/file/FileTreeWalker.java ! src/share/classes/java/nio/file/Files.java + test/java/nio/file/Files/FaultyFileSystem.java ! test/java/nio/file/Files/PassThroughFileSystem.java + test/java/nio/file/Files/StreamTest.java Changeset: b9b26b424bfc Author: mduigou Date: 2013-05-18 18:55 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b9b26b424bfc Merge Changeset: 08ebdb2b53cc Author: plevart Date: 2013-05-17 14:41 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/08ebdb2b53cc 8014477: (str) Race condition in String.contentEquals when comparing with StringBuffer Reviewed-by: alanb, mduigou, dholmes ! src/share/classes/java/lang/String.java + test/java/lang/String/StringContentEqualsBug.java Changeset: 6a9148865139 Author: sherman Date: 2013-05-20 11:56 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6a9148865139 8004789: (zipfs) zip provider doesn't work correctly with file systems providers rather than the default Summary: to use Files.createTempFile(...) to create the temp file on the same fs as the targeted path. Reviewed-by: alanb, sherman Contributed-by: philippe.marschall at gmail.com ! src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystem.java Changeset: 1baf3d7fe2f1 Author: dholmes Date: 2013-05-21 01:17 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/1baf3d7fe2f1 8014857: Enable ergonomic VM selection in arm/jvm.cfg Reviewed-by: darcy ! src/solaris/bin/arm/jvm.cfg Changeset: 20925206aef8 Author: alanb Date: 2013-05-21 08:53 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/20925206aef8 8014892: More ProblemList.txt updates (5/2013) Reviewed-by: alanb Contributed-by: amy.lu at oracle.com ! test/ProblemList.txt Changeset: 63c7e92e5e6d Author: yhuang Date: 2013-05-20 23:03 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/63c7e92e5e6d 7074882: Locale data needs correction (Month names for Maltese language) Reviewed-by: naoto ! src/share/classes/sun/text/resources/mt/FormatData_mt.java ! test/sun/text/resources/LocaleData ! test/sun/text/resources/LocaleDataTest.java Changeset: 1fba35ef4360 Author: yhuang Date: 2013-05-21 01:50 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/1fba35ef4360 Merge Changeset: 48e8a6e0c805 Author: chegar Date: 2013-05-22 13:50 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/48e8a6e0c805 8010182: Thread safety of Thread get/setName() Reviewed-by: dholmes, alanb, mduigou ! src/share/classes/java/lang/Thread.java Changeset: 4b555b53dc57 Author: mduigou Date: 2013-05-22 09:59 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/4b555b53dc57 8014819: set max size for jtreg testvms Reviewed-by: alanb, darcy ! test/Makefile Changeset: bcfab7056195 Author: lana Date: 2013-05-22 09:57 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bcfab7056195 Merge Changeset: 760d4187597a Author: lana Date: 2013-05-22 12:09 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/760d4187597a Merge Changeset: 50fde3eeb48c Author: naoto Date: 2013-05-22 16:43 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/50fde3eeb48c 7056126: DateFormatSymbols documentation has incorrect description about DateFormat 7083668: Sample code in ListResourceBundle is still not correct Reviewed-by: okutsu ! src/share/classes/java/text/DateFormatSymbols.java ! src/share/classes/java/util/ListResourceBundle.java Changeset: a1a8e71e130a Author: dholmes Date: 2013-05-22 20:21 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a1a8e71e130a 8014814: (str) StringBuffer "null" is not appended Reviewed-by: alanb ! src/share/classes/java/lang/StringBuffer.java ! test/java/lang/StringBuffer/ToStringCache.java Changeset: e764bb01567e Author: darcy Date: 2013-05-22 20:03 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e764bb01567e 8014836: Have GenericDeclaration extend AnnotatedElement Reviewed-by: abuckley, jfranck ! src/share/classes/java/lang/Class.java ! src/share/classes/java/lang/reflect/GenericDeclaration.java Changeset: 0da6485cf656 Author: nloodin Date: 2013-05-23 15:50 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0da6485cf656 8014048: Online user guide of jconsole points incorrect link Reviewed-by: mchung, sla, jbachorik ! src/share/classes/sun/tools/jconsole/AboutDialog.java ! src/share/classes/sun/tools/jconsole/resources/messages.properties ! src/share/classes/sun/tools/jconsole/resources/messages_ja.properties ! src/share/classes/sun/tools/jconsole/resources/messages_zh_CN.properties Changeset: 3b23e3529ab3 Author: dl Date: 2013-05-23 18:34 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/3b23e3529ab3 8014076: Arrays parallel and serial sorting improvements Reviewed-by: chegar, mduigou ! src/share/classes/java/util/Arrays.java ! src/share/classes/java/util/ArraysParallelSortHelpers.java ! src/share/classes/java/util/ComparableTimSort.java ! src/share/classes/java/util/DualPivotQuicksort.java ! src/share/classes/java/util/TimSort.java ! test/java/util/Arrays/ParallelSorting.java Changeset: 6816afd70a68 Author: weijun Date: 2013-05-24 17:15 +0800 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6816afd70a68 8014196: ktab creates a file with zero kt_vno Reviewed-by: valeriep ! src/share/classes/sun/security/krb5/internal/ktab/KeyTab.java ! src/windows/classes/sun/security/krb5/internal/tools/Ktab.java + test/sun/security/krb5/tools/KtabZero.java + test/sun/security/krb5/tools/ktzero.sh Changeset: 5e769206f036 Author: ksrini Date: 2013-05-24 17:01 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5e769206f036 8007333: [launcher] removes multiple back slashes Reviewed-by: alanb, akhil ! src/windows/bin/cmdtoargs.c ! test/tools/launcher/Arrrghs.java Changeset: d78f91ab0e96 Author: uta Date: 2013-05-27 15:18 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/d78f91ab0e96 8014394: (fs) WatchService failing when watching \\server\$d Reviewed-by: alanb ! src/windows/classes/sun/nio/fs/WindowsConstants.java ! src/windows/classes/sun/nio/fs/WindowsNativeDispatcher.java ! src/windows/classes/sun/nio/fs/WindowsWatchService.java ! src/windows/native/sun/nio/fs/WindowsNativeDispatcher.c Changeset: 0b8dab7fec54 Author: plevart Date: 2013-05-27 09:41 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0b8dab7fec54 7038914: VM could throw uncaught OOME in ReferenceHandler thread Summary: Catch OutOfMemoryError in reference handler thread if caused by allocation of an InterruptedException Reviewed-by: dholmes, alanb ! src/share/classes/java/lang/ref/Reference.java + test/java/lang/ref/OOMEInReferenceHandler.java Changeset: a2dc42667df3 Author: chegar Date: 2013-05-27 14:00 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a2dc42667df3 8015439: Minor/sync/cleanup of ConcurrentHashMap Reviewed-by: chegar Contributed-by: Doug Lea
, Chris Hegarty ! src/share/classes/java/util/concurrent/ConcurrentHashMap.java Changeset: 9bbf2237071e Author: chegar Date: 2013-05-27 15:24 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/9bbf2237071e Merge Changeset: bbf6e6222726 Author: nloodin Date: 2013-05-27 17:10 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bbf6e6222726 6470730: Disconnect button leads to wrong popup message Reviewed-by: dcubed, sla, egahlin ! src/share/classes/sun/tools/jconsole/VMPanel.java Changeset: 7d9fab5d86cd Author: jbachorik Date: 2013-05-28 15:57 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/7d9fab5d86cd 8005472: com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.sh failed on windows Reviewed-by: chegar, smarks, dfuchs ! test/ProblemList.txt ! test/com/sun/jmx/remote/NotificationMarshalVersions/Client/Client.java ! test/com/sun/jmx/remote/NotificationMarshalVersions/Server/Server.java + test/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.java - test/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.sh Changeset: 7d7bfce34a79 Author: dsamersoff Date: 2013-05-28 18:46 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/7d7bfce34a79 8014420: Default JDP address does not match the one assigned by IANA Summary: JDP protocol defaults changed to IANA assigned values Reviewed-by: dholmes, jbachorik, hirt Contributed-by: fweimer at redhat.com ! src/share/classes/sun/management/Agent.java ! src/share/classes/sun/management/jdp/package-info.java ! test/sun/management/jdp/JdpTest.sh Changeset: b16a8b4ae6b4 Author: robm Date: 2013-05-28 16:35 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b16a8b4ae6b4 7038105: File.isHidden() should return true for pagefile.sys and hiberfil.sys Reviewed-by: alanb ! src/windows/native/java/io/WinNTFileSystem_md.c ! test/java/io/File/IsHidden.java Changeset: 7fa2d1dcb8f6 Author: sherman Date: 2013-05-28 10:42 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/7fa2d1dcb8f6 8001750: CharsetDecoder.replacement should not be changeable except via replaceWith method Summary: to make defensive copy for set/get replacement byte array Reviewed-by: martin ! src/share/classes/java/nio/charset/Charset-X-Coder.java.template ! src/share/classes/sun/nio/cs/UTF_8.java ! src/share/classes/sun/nio/cs/ext/DoubleByte.java ! src/share/classes/sun/nio/cs/ext/HKSCS.java Changeset: b99d56d1aa3f Author: naoto Date: 2013-05-28 14:02 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b99d56d1aa3f 6251788: (rb) PropertyResourceBundle doesn't document exceptions Reviewed-by: okutsu ! src/share/classes/java/util/PropertyResourceBundle.java Changeset: 1652a22cf6e7 Author: xuelei Date: 2013-05-28 18:47 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/1652a22cf6e7 8010815: some constructors issues in com.sun.jndi.toolkit Reviewed-by: alanb ! src/share/classes/com/sun/jndi/toolkit/ctx/Continuation.java ! src/share/classes/com/sun/jndi/toolkit/dir/LazySearchEnumerationImpl.java ! src/share/classes/com/sun/jndi/toolkit/url/GenericURLContext.java Changeset: e59d7f0f36f7 Author: ewang Date: 2013-05-28 22:22 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e59d7f0f36f7 8009258: TEST_BUG:java/io/pathNames/GeneralWin32.java fails intermittently Reviewed-by: dxu, alanb Contributed-by: yiming.wang at oracle.com ! test/java/io/pathNames/General.java ! test/java/io/pathNames/GeneralWin32.java Changeset: bd6d3801347b Author: sla Date: 2013-05-29 09:42 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bd6d3801347b 8015440: java/lang/management/MemoryMXBean/ResetPeakMemoryUsage.java fails with RuntimeException Summary: Make sure serial gc compacts heap every time Reviewed-by: mchung, brutisso, nloodin ! test/java/lang/management/MemoryMXBean/ResetPeakMemoryUsage.java Changeset: 2b3242a69a44 Author: alanb Date: 2013-05-29 10:24 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/2b3242a69a44 8014928: (fs) Files.readAllBytes() copies content to new array when content completely read Reviewed-by: martin ! src/share/classes/java/nio/file/Files.java Changeset: 00ad19610e75 Author: vinnie Date: 2013-05-29 14:57 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/00ad19610e75 7174966: With OCSP enabled on Java 7 get error 'Wrong key usage' with Comodo certificate Reviewed-by: xuelei ! src/share/classes/sun/security/provider/certpath/OCSPResponse.java Changeset: 5d9273a5a84e Author: lana Date: 2013-05-29 16:58 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5d9273a5a84e Merge - test/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.sh Changeset: 7eae7c89dab4 Author: lana Date: 2013-06-03 23:23 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/7eae7c89dab4 Merge - test/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.sh Changeset: 251c9524952b Author: mduigou Date: 2013-06-05 13:28 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/251c9524952b Merge ! .hgtags - .jcheck/conf ! src/share/classes/java/lang/String.java ! src/share/classes/java/lang/StringBuffer.java ! src/share/classes/java/nio/file/FileTreeIterator.java ! src/share/classes/java/nio/file/Files.java ! src/share/classes/java/util/Arrays.java ! src/share/classes/java/util/ArraysParallelSortHelpers.java ! src/share/classes/java/util/ComparableTimSort.java ! src/share/classes/java/util/DualPivotQuicksort.java ! src/share/classes/java/util/Spliterator.java ! src/share/classes/java/util/TimSort.java ! src/share/classes/java/util/concurrent/ConcurrentHashMap.java ! src/share/classes/java/util/function/BiConsumer.java ! src/share/classes/java/util/function/BiFunction.java ! src/share/classes/java/util/function/BiPredicate.java ! src/share/classes/java/util/function/BooleanSupplier.java ! src/share/classes/java/util/function/Consumer.java ! src/share/classes/java/util/function/DoubleBinaryOperator.java ! src/share/classes/java/util/function/DoubleConsumer.java ! src/share/classes/java/util/function/DoubleFunction.java ! src/share/classes/java/util/function/DoublePredicate.java ! src/share/classes/java/util/function/DoubleSupplier.java ! src/share/classes/java/util/function/DoubleUnaryOperator.java ! src/share/classes/java/util/function/Function.java ! src/share/classes/java/util/function/IntBinaryOperator.java ! src/share/classes/java/util/function/IntConsumer.java ! src/share/classes/java/util/function/IntFunction.java ! src/share/classes/java/util/function/IntPredicate.java ! src/share/classes/java/util/function/IntSupplier.java ! src/share/classes/java/util/function/IntUnaryOperator.java ! src/share/classes/java/util/function/LongBinaryOperator.java ! src/share/classes/java/util/function/LongConsumer.java ! src/share/classes/java/util/function/LongFunction.java ! src/share/classes/java/util/function/LongPredicate.java ! src/share/classes/java/util/function/LongSupplier.java ! src/share/classes/java/util/function/LongUnaryOperator.java ! src/share/classes/java/util/function/ObjDoubleConsumer.java ! src/share/classes/java/util/function/ObjIntConsumer.java ! src/share/classes/java/util/function/ObjLongConsumer.java ! src/share/classes/java/util/function/Predicate.java ! src/share/classes/java/util/function/Supplier.java ! src/share/classes/java/util/function/ToDoubleBiFunction.java ! src/share/classes/java/util/function/ToDoubleFunction.java ! src/share/classes/java/util/function/ToIntBiFunction.java ! src/share/classes/java/util/function/ToIntFunction.java ! src/share/classes/java/util/function/ToLongBiFunction.java ! src/share/classes/java/util/function/ToLongFunction.java ! src/share/classes/java/util/function/UnaryOperator.java ! test/Makefile ! test/ProblemList.txt ! test/java/nio/file/Files/FaultyFileSystem.java ! test/java/nio/file/Files/PassThroughFileSystem.java ! test/java/nio/file/Files/StreamTest.java - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorLateBindingFailFastTest.java - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTraversingAndSplittingTest.java From jed at wesleysmith.io Wed Jun 5 16:24:44 2013 From: jed at wesleysmith.io (Jed Wesley-Smith) Date: Thu, 6 Jun 2013 09:24:44 +1000 Subject: Optional -> OptionalResult In-Reply-To: References: Message-ID: It bears repeating that Option is not a solution to null, and is not peddled as such. It is a solution to optionality, for which null is often used (see Map::get for instance). This has explained before, see for instance: http://mail.openjdk.java.net/pipermail/lambda-dev/2012-September/006050.html As to List> and the like, you never see this kind of thing in actual code, apart from the input to something like Iterables.concat(Iterable>)* which produces an Iterable. Indeed, this is essentially the motivation for and use case of the bind/flatMap method on monads ? to not end up with nested boxes. Optional now has this very useful method Optional::flatMap(Function>) -> Optional. No nesting! I don't think Java is actually a mutable language. If it was, you'd be able to add your ? operator. cheers, jed. * BTW this is one of the motivations for wanting Optional to implement Iterable. On 5 June 2013 19:20, Stephen Colebourne wrote: > On 5 June 2013 01:06, Jed Wesley-Smith wrote: > > Map>> is clearly a straw-man. It does not make any > sense to > > have a Map that has an optional key, nor does it make any sense to have > an > > optional result, map already is a partial function! Regardless, "large" > > generic types are not by themselves scary ? indeed, they are very > useful. We > > already have the ability to hide complex product types at the value > level, > > we just need a way to alias them at the type level. > > Here is what Tim Pierls wrote: > On 4 June 2013 15:57, Tim Peierls wrote: > > I try to use Optional purely as a return type, and I try to avoid using > > monstrosities like List> (or worse) in an API. I confess > that > > in my first flush of excitement at having Optional, I went way overboard > > and did, in fact, create some truly horrible method signatures, but the > > crime conveys its own punishment, and I quickly learned what not to do. > > While Tim clearly learnt the mistake, the reality is that APIs were > produced with poor method signatures. Developers will over-use > Optional, at least in part because the Scala community pushes it as > the solution to null, which it isn't. > > The consistent rejection of adding the most basic language tools for > null (?. and ?:) is another factor (never mind null in the type > system). Developers know that null is a right royal pain and a problem > they'd love to solve. Since they are forbiidden useful language level > solutions, some will see Optional as the new nirvana and thus > over-use it. To call it a straw man is to misunderstand why better > null-handling in Java was repeatedly voted by developers as the > language change they want. > > > Option is not merely useful as a result type. It is useful anywhere you > wish > > to indicate that a value is optional. For instance, in an input form in a > > GUI there may be non-mandatory input fields, or there may be inputs to a > > method that are not necessary for the caller to supply. You may consider > > overloading in the second case, but for a form structure this can prove > > unwieldy. > > No, I'd just use null for something that is optional. It what Java has > used for donkeys years, what works with the JavaBean spec and doesn't > require extra thinking. What it does require is documenting whether > the parameter/return value can be null or not, but that should be done > anyway. > > The key point is that Java (and Scala) still have null. Null cannot be > removed or eliminated. Any variable declared as type Optional > can still be set to null. Optional is a false promise, making you feel > good, but not actually removing the danger of null. > > > JodaTime fought the battle to > > bring immutability to a date API and is clearly superior to the previous > > library for being so. Immutability is a corner-stone of what makes FP ? > the > > ability to program with values. There is no need to believe there is a > > disconnect, or that you are somehow on the "other side" from functional > > programmers. We are all on the same side, trying to make better libraries > > and applications that are easier to reason about, easier to write and > easier > > to maintain. > > Java is a mutable language, far from the ideals of FP. Joda-Time and > JSR-310 provide an immutable low-level library, which has real and > tangible benefits. But trying to expand that immutability beyond > low-level libraries given (a) the language facilities available in > Java, and (b) the history of Java, is at best painful. > > Stephen > > From maurizio.cimadamore at oracle.com Thu Jun 6 08:05:01 2013 From: maurizio.cimadamore at oracle.com (maurizio.cimadamore at oracle.com) Date: Thu, 06 Jun 2013 15:05:01 +0000 Subject: hg: lambda/lambda/langtools: 8016060: Lambda isn't compiled with return statement; ... Message-ID: <20130606150512.7BAB248006@hg.openjdk.java.net> Changeset: 72daa9684315 Author: mcimadamore Date: 2013-06-06 16:04 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/72daa9684315 8016060: Lambda isn't compiled with return statement 8016059: Cannot compile following lambda ! src/share/classes/com/sun/tools/javac/code/Type.java ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java + test/tools/javac/lambda/TargetType75.java From paul.sandoz at oracle.com Thu Jun 6 08:35:04 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 06 Jun 2013 15:35:04 +0000 Subject: hg: lambda/lambda/jdk: Remove OutOfMemoryException catching in spliterators as this tends Message-ID: <20130606153537.4539B48010@hg.openjdk.java.net> Changeset: b3afa63e3a02 Author: psandoz Date: 2013-06-06 17:34 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b3afa63e3a02 Remove OutOfMemoryException catching in spliterators as this tends to just push the error around and induce other issues that are hard to track down. TODO: AbstractTask.compute needs to be modified to detect imbalanced splits produced by such spliterators, detect if queued tasks are greater than a threshold, and if so steal work, rather than creating more work that uses of more memory. ! src/share/classes/java/util/LinkedList.java ! src/share/classes/java/util/Spliterators.java ! src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java ! src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java ! src/share/classes/java/util/concurrent/LinkedBlockingDeque.java ! src/share/classes/java/util/concurrent/LinkedBlockingQueue.java ! src/share/classes/java/util/concurrent/LinkedTransferQueue.java From paul.sandoz at oracle.com Thu Jun 6 08:56:19 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 06 Jun 2013 15:56:19 +0000 Subject: hg: lambda/lambda/jdk: Abstract out the forEachRemaining method. Message-ID: <20130606155650.DBC7D48011@hg.openjdk.java.net> Changeset: a679777d55f2 Author: psandoz Date: 2013-06-06 17:55 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a679777d55f2 Abstract out the forEachRemaining method. ! src/share/classes/java/util/PrimitiveIterator.java From henry.jen at oracle.com Fri Jun 7 00:45:41 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Fri, 07 Jun 2013 07:45:41 +0000 Subject: hg: lambda/lambda/jdk: Revert comparing renaming and narrow type changes Message-ID: <20130607074603.E505D4806A@hg.openjdk.java.net> Changeset: 20b3fd9c7d36 Author: henryjen Date: 2013-06-07 00:45 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/20b3fd9c7d36 Revert comparing renaming and narrow type changes ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Comparators.java ! src/share/classes/java/util/stream/Collector.java ! src/share/classes/java/util/stream/Collectors.java ! test/java/util/Comparator/BasicTest.java ! test/java/util/Comparators/BasicTest.java From mark at talios.com Fri Jun 7 16:07:56 2013 From: mark at talios.com (Mark Derricutt) Date: Sat, 08 Jun 2013 11:07:56 +1200 Subject: Class verifier issues with unboxing method handles In-Reply-To: <51A5E59F.9040007@oracle.com> References: <51A5543B.10506@talios.com> <51A55E5E.4020605@oracle.com> <51A5E59F.9040007@oracle.com> Message-ID: <51B267CC.8000303@talios.com> Maurizio / David / others... Does anyone know if anything has come of this? I don't see any further posts on this thread on either hotspot-dev or lambda-dev. Thanks, Mark Maurizio Cimadamore wrote: > > David, Mark, > a minimal test case to reproduce the issue is this: > > interface IntFunction { > int m(X x); > } > > class Test { > public static void main(String[] args) { > IntFunction s = Integer::new; > } > } > > > Looking at the javap output, in particular at the indy call details, > we find this: > > BootstrapMethods: > 0: #15 invokestatic > java/lang/invoke/LambdaMetafactory.metaFactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite; > > > Method arguments: > #16 invokeinterface IntFunction.m:(Ljava/lang/Object;)I > #17 newinvokespecial java/lang/Integer."":(Ljava/lang/String;)V > #18 (Ljava/lang/String;)I > > > This seems correct; however, judging from the runtime error, it seems > like the metafactory is not unboxing the Integer instance back to int > (which is the expected return value of the implemented method). Hence > the 292 link failure. Robert, Brian can you confirm? > > Maurizio > > > On 29/05/13 02:48, David Holmes wrote: >> >> Hi Mark, >> >> cc'ing lambda-dev. This may be a bug, a version mismatch, or something >> else. The lambda-dev folk will know. >> >> David >> >> On 29/05/2013 11:04 AM, Mark Derricutt wrote: >>> >>> Hi all, >>> >>> Mark Reinhold suggested I posted this question/bug report to >>> hotspot-dev >>> rather than jdk8-dev so here goes. >>> >>> I have a fairly simple test case using the new streams API: >>> >>> public static void main(String[] args) { >>> List strings = Arrays.asList("1", "2", "3", "4", "5"); >>> strings.stream() >>> .mapToInt(s -> new Integer(s)) >>> .forEach(i -> System.out.println(String.format("int %d", i))); >>> } >>> >>> >>> which compiles, runs, and prints out what I expect: >>> >>> int 1 >>> int 2 >>> int 3 >>> int 4 >>> int 5 >>> >>> >>> Given that mapToInt() is returning an IntegerStream wrapping primitive >>> ints, the result of my closure is successfully autoboxed down to an int >>> and all is happy with the world. >>> >>> If I change this code to be: >>> >>> strings.stream() >>> .mapToInt(Integer::parseInt) >>> .forEach(i -> System.out.println(String.format("int %d", i))); >>> >>> Again, everything works as expected as Integer::parseInt returns an >>> int, >>> so there's no boxing. >>> >>> Changing this once again to: >>> >>> strings.stream() >>> .mapToInt(Integer::valueOf) >>> .forEach(i -> System.out.println(String.format("int %d", i))); >>> >>> I also see the expected result, Integer::valueOf returns an Integer >>> which is then being boxed down to an int. >>> >>> However, if I change the code to: >>> >>> strings.stream() >>> .mapToInt(Integer::new) >>> .forEach(i -> System.out.println(String.format("int %d", i))); >>> >>> which, if I understand correctly - Integer::new should be returning a >>> method handle to the constructor. IntelliJ IDEA 13 autocompletes this >>> for me, and hyperlinks to the Integer(String s) constructor, javac >>> successfully compiles the code so my -assumption- is that the >>> constructor would be called, returning an Integer which is then boxed >>> down to an int, however, this is what I get: >>> >>> Exception in thread "main" java.lang.BootstrapMethodError: call site >>> initialization exception >>> at java.lang.invoke.CallSite.makeSite(CallSite.java:298) >>> at >>> java.lang.invoke.MethodHandleNatives.linkCallSite(MethodHandleNatives.java:294) >>> >>> >>> >>> at com.talios.test.TestJdk.main(TestJdk.java:12) >>> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >>> at >>> sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >>> >>> >>> >>> at >>> sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >>> >>> >>> >>> at java.lang.reflect.Method.invoke(Method.java:491) >>> at >>> com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) >>> Caused by: java.lang.VerifyError: Bad type on operand stack >>> Exception Details: >>> Location: >>> com/talios/test/TestJdk$$Lambda$1.applyAsInt(Ljava/lang/Object;)I >>> @11: ireturn >>> Reason: >>> Type 'java/lang/Integer' (current frame, stack[0]) is not >>> assignable to integer >>> Current Frame: >>> bci: @11 >>> flags: { } >>> locals: { 'com/talios/test/TestJdk$$Lambda$1', 'java/lang/Object' } >>> stack: { 'java/lang/Integer' } >>> Bytecode: >>> 0000000: bb00 0e59 2bc0 0010 b700 13ac >>> >>> at java.lang.Class.getDeclaredConstructors0(Native Method) >>> at java.lang.Class.privateGetDeclaredConstructors(Class.java:2536) >>> at java.lang.Class.getDeclaredConstructors(Class.java:1928) >>> at >>> java.lang.invoke.InnerClassLambdaMetafactory$1.run(InnerClassLambdaMetafactory.java:147) >>> >>> >>> >>> at >>> java.lang.invoke.InnerClassLambdaMetafactory$1.run(InnerClassLambdaMetafactory.java:144) >>> >>> >>> >>> at java.security.AccessController.doPrivileged(Native Method) >>> at >>> java.lang.invoke.InnerClassLambdaMetafactory.buildCallSite(InnerClassLambdaMetafactory.java:143) >>> >>> >>> >>> at >>> java.lang.invoke.LambdaMetafactory.metaFactory(LambdaMetafactory.java:191) >>> >>> >>> at java.lang.invoke.CallSite.makeSite(CallSite.java:283) >>> ... 7 more >>> >>> This is on OSX Mountain Lion, with JDK 8 Build 91. >>> >>> Have I walked in an obscure corner case of method handle breakage and >>> found something new, or is this a new problem? >>> >>> Cheers, >>> Mark >>> >> > From henry.jen at oracle.com Sat Jun 8 01:27:26 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Sat, 08 Jun 2013 08:27:26 +0000 Subject: hg: lambda/lambda/jdk: 2 new changesets Message-ID: <20130608082802.6E0FB480C7@hg.openjdk.java.net> Changeset: 16932889cb2d Author: henryjen Date: 2013-06-07 23:50 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/16932889cb2d Comparators goes package private ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Comparators.java ! src/share/classes/java/util/Map.java ! src/share/classes/java/util/TreeMap.java ! src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java ! src/share/classes/java/util/function/BinaryOperator.java ! src/share/classes/java/util/stream/Collectors.java ! src/share/classes/java/util/stream/ReferencePipeline.java ! test/java/util/Comparator/TypeTest.java - test/java/util/Comparators/BasicTest.java + test/java/util/Map/EntryComparators.java + test/java/util/function/BinaryOperator/BasicTest.java Changeset: 40d86306a10a Author: henryjen Date: 2013-06-07 23:53 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/40d86306a10a Rename Comparator::reverse to Comparator::reversed ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Comparators.java ! test/java/util/Comparator/BasicTest.java ! test/java/util/stream/Stream/EmployeeStreamTest.java ! test/java/util/stream/Stream/StringBuilderStreamTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java From paul.sandoz at oracle.com Mon Jun 10 06:21:20 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Mon, 10 Jun 2013 13:21:20 +0000 Subject: hg: lambda/lambda/jdk: Balanced spltierator implementation for spined buffers. Message-ID: <20130610132156.1095D480F1@hg.openjdk.java.net> Changeset: 8b5895496c63 Author: psandoz Date: 2013-06-10 15:13 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8b5895496c63 Balanced spltierator implementation for spined buffers. Contributed-by: Peter Levart , Paul Sandoz ! src/share/classes/java/util/stream/SpinedBuffer.java From paul.sandoz at oracle.com Mon Jun 10 07:58:31 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Mon, 10 Jun 2013 16:58:31 +0200 Subject: Alternative Spliterator for SpinedBuffer In-Reply-To: <51700598.2030301@gmail.com> References: <20130411195344.E6A4C48215@hg.openjdk.java.net> <516823FD.2010008@gmail.com> <51684018.6010104@oracle.com> <51700598.2030301@gmail.com> Message-ID: Hi Peter, Finally got around to processing this, sorry for the delay. I integrated the patch into the latest code base and made a couple of tweaks here and there: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8b5895496c63 -- I have also prepared a patch for tl, since this plus some minor changes is mostly isolated from some other implementation stuff: http://cr.openjdk.java.net/~psandoz/tl/JDK-8016251-spinedBuffer-splitr/webrev/ Paul. On Apr 18, 2013, at 4:39 PM, Peter Levart wrote: > Hi Brian, > > I did some performance measurements. The most obvious difference in > performance is observed when individual operations in the stream > pipeline take relatively long time, but even with fast individual > operations, the performance benefit can be observed. For example, this > test code: > > public class StreamBuilderTest { > > static long test(boolean parallel) { > StreamBuilder.OfInt builder = Streams.intBuilder(); > for (int i = 0; i < 10000000; i++) { > builder.accept(i); > } > > try { > System.gc(); > Thread.sleep(500L); > System.gc(); > Thread.sleep(500L); > System.gc(); > Thread.sleep(500L); > } catch (InterruptedException e) {} > > long t0 = System.nanoTime(); > double pi = (parallel ? builder.build().parallel() : > builder.build().sequential()) > .mapToDouble(i -> > (i & 1) == 0 > ? 4d / ((2d * i + 2d) * (2d * i + 3d) * (2d > * i + 4d)) > : -4d / ((2d * i + 2d) * (2d * i + 3d) * > (2d * i + 4d)) > ) > .sum() + 3d; > long t = System.nanoTime() - t0; > System.out.println(" pi=" + pi + " in " + t + " ns"); > return t; > } > > static void testN(int n, boolean parallel) { > System.out.println(" warm-up"); > for (int i = 0; i < 5; i++) test(parallel); > System.out.println(" measure"); > long tSum = 0; > for (int i = 0; i < n; i++) tSum += test(parallel); > System.out.println(" average: " + ((double) tSum / n) + " ns"); > } > > public static void main(String[] args) { > System.out.println("Sequential:"); > testN(10, false); > System.out.println("Parallel:"); > testN(10, true); > } > } > > > Prints the following with current Spliterator implementation: > > Sequential: > warm-up > pi=3.1415926535897913 in 115127248 ns > pi=3.1415926535897913 in 70426262 ns > pi=3.1415926535897913 in 74633777 ns > pi=3.1415926535897913 in 70558263 ns > pi=3.1415926535897913 in 68995773 ns > measure > pi=3.1415926535897913 in 67116015 ns > pi=3.1415926535897913 in 72918687 ns > pi=3.1415926535897913 in 68584475 ns > pi=3.1415926535897913 in 67871743 ns > pi=3.1415926535897913 in 72419475 ns > pi=3.1415926535897913 in 67932912 ns > pi=3.1415926535897913 in 71237839 ns > pi=3.1415926535897913 in 69636412 ns > pi=3.1415926535897913 in 66849404 ns > pi=3.1415926535897913 in 72220404 ns > average: 6.96787366E7 ns > Parallel: > warm-up > pi=3.141592653589793 in 27772347 ns > pi=3.141592653589793 in 18209373 ns > pi=3.141592653589793 in 18516459 ns > pi=3.141592653589793 in 16655371 ns > pi=3.141592653589793 in 19956267 ns > measure > pi=3.141592653589793 in 21184246 ns > pi=3.141592653589793 in 20352169 ns > pi=3.141592653589793 in 21195477 ns > pi=3.141592653589793 in 21287557 ns > pi=3.141592653589793 in 16230650 ns > pi=3.141592653589793 in 20035680 ns > pi=3.141592653589793 in 18355295 ns > pi=3.141592653589793 in 21971399 ns > pi=3.141592653589793 in 20552600 ns > pi=3.141592653589793 in 19332368 ns > average: 2.00497441E7 ns > > > And the following with alternative Spliterator: > > Sequential: > warm-up > pi=3.1415926535897913 in 111301836 ns > pi=3.1415926535897913 in 73685822 ns > pi=3.1415926535897913 in 68454448 ns > pi=3.1415926535897913 in 71583982 ns > pi=3.1415926535897913 in 68397094 ns > measure > pi=3.1415926535897913 in 67047559 ns > pi=3.1415926535897913 in 67424431 ns > pi=3.1415926535897913 in 67079863 ns > pi=3.1415926535897913 in 73486488 ns > pi=3.1415926535897913 in 76055108 ns > pi=3.1415926535897913 in 74366550 ns > pi=3.1415926535897913 in 69808517 ns > pi=3.1415926535897913 in 65960535 ns > pi=3.1415926535897913 in 65969289 ns > pi=3.1415926535897913 in 70446736 ns > average: 6.97645076E7 ns > Parallel: > warm-up > pi=3.1415926535897913 in 21529026 ns > pi=3.1415926535897913 in 15567913 ns > pi=3.1415926535897913 in 15090407 ns > pi=3.1415926535897913 in 15071715 ns > pi=3.1415926535897913 in 14593676 ns > measure > pi=3.1415926535897913 in 15227210 ns > pi=3.1415926535897913 in 15406588 ns > pi=3.1415926535897913 in 14631733 ns > pi=3.1415926535897913 in 15719352 ns > pi=3.1415926535897913 in 15201443 ns > pi=3.1415926535897913 in 16537214 ns > pi=3.1415926535897913 in 15365526 ns > pi=3.1415926535897913 in 14674482 ns > pi=3.1415926535897913 in 19898638 ns > pi=3.1415926535897913 in 16947804 ns > average: 1.5960999E7 ns > > > But don't take this measurements for granted. You can try it for > yourself. I'm sure you have lots of performance tests that involve > SpinedBuffer spliterator. Here's the updated patch that also > incorporates primitive variants: > > http://dl.dropboxusercontent.com/u/101777488/jdk8-lambda/SpinedBufferAltSpliterator/webrev.02/index.html > > I made it so that original/alternative implementation can be switched > with a system property so that the same test can be run with both > implementations easily to compare results. > > > Regards, Peter > > > > On 04/12/2013 07:10 PM, Brian Goetz wrote: >> Thanks for taking a look at this code! Your approach does look like >> it would yield a better decomposition -- and this is a really good >> time to be looking at this, as the APIs have mostly settled. >> >> I agree that there are improvements to be made here. Have your >> performance measurements as improved runtime as well as reduced task >> count? >> >> On 4/12/2013 11:10 AM, Peter Levart wrote: >>> On 04/11/2013 09:53 PM, brian.goetz at oracle.com wrote: >>>> Changeset: 5e7f8797b9c1 >>>> Author: briangoetz >>>> Date: 2013-04-11 15:53 -0400 >>>> URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5e7f8797b9c1 >>>> >>>> Spec pass on StreamBuilder >>>> >>>> ! src/share/classes/java/util/stream/StreamBuilder.java >>>> ! src/share/classes/java/util/stream/Streams.java >>>> >>>> >>> >>> Hi, >>> >>> I played a little with StreamBuilder and it works quite optimally using >>> private SpinedBuffer under the hood. The only sub-optimality is when it >>> starts small (min. 16 elements) and then grows big and after that it is >>> used in a parallel computation where leaf task maximum size is more than >>> 16 elements. For example, this code: >>> >>> >>> public class SpinedBufferTest { >>> >>> static int dump(Spliterator spliterator, int level, int >>> iterateSize) { >>> System.out.print(" ".substring(0, level)); >>> System.out.print(spliterator.estimateSize()); >>> Spliterator spl2; >>> if (spliterator.estimateSize() > iterateSize && (spl2 = >>> spliterator.trySplit()) != null) { >>> System.out.println(": split " + spl2.estimateSize() + " + " >>> + spliterator.estimateSize()); >>> return dump(spl2, level + 1, iterateSize) + >>> dump(spliterator, level + 1, iterateSize); >>> } >>> else { >>> Integer[] minMax = new Integer[2]; >>> spliterator.forEachRemaining(x -> { >>> minMax[0] = minMax[0] == null ? x : Math.min(minMax[0], >>> x); >>> minMax[1] = minMax[1] == null ? x : Math.max(minMax[1], >>> x); >>> }); >>> System.out.println(": (" + minMax[0] + "..." + minMax[1] + >>> ")"); >>> return 1; >>> } >>> } >>> >>> public static void main(String[] args) { >>> SpinedBuffer buf = new SpinedBuffer<>(); >>> for (int i = 0; i < 16384; i++) { >>> buf.accept(i); >>> } >>> int leafs = dump(buf.spliterator(), 0, 1024); >>> System.out.println("\nTotal leafs: " + leafs); >>> } >>> } >>> >>> >>> Prints the splits that would occur for 16k elements when max. leaf task >>> size is 1k: >>> >>> >>> 16384: split 16 + 16368 >>> 16: (0...15) >>> 16368: split 16 + 16352 >>> 16: (16...31) >>> 16352: split 32 + 16320 >>> 32: (32...63) >>> 16320: split 64 + 16256 >>> 64: (64...127) >>> 16256: split 128 + 16128 >>> 128: (128...255) >>> 16128: split 256 + 15872 >>> 256: (256...511) >>> 15872: split 512 + 15360 >>> 512: (512...1023) >>> 15360: split 1024 + 14336 >>> 1024: (1024...2047) >>> 14336: split 2048 + 12288 >>> 2048: split 1024 + 1024 >>> 1024: (2048...3071) >>> 1024: (3072...4095) >>> 12288: split 4096 + 8192 >>> 4096: split 2048 + 2048 >>> 2048: split 1024 + 1024 >>> 1024: (4096...5119) >>> 1024: (5120...6143) >>> 2048: split 1024 + 1024 >>> 1024: (6144...7167) >>> 1024: (7168...8191) >>> 8192: split 4096 + 4096 >>> 4096: split 2048 + 2048 >>> 2048: split 1024 + 1024 >>> 1024: (8192...9215) >>> 1024: (9216...10239) >>> 2048: split 1024 + 1024 >>> 1024: (10240...11263) >>> 1024: (11264...12287) >>> 4096: split 2048 + 2048 >>> 2048: split 1024 + 1024 >>> 1024: (12288...13311) >>> 1024: (13312...14335) >>> 2048: split 1024 + 1024 >>> 1024: (14336...15359) >>> 1024: (15360...16383) >>> >>> Total leafs: 22 >>> >>> >>> 7 leaf tasks are half the max. size or less. >>> >>> Now SpinedBuffer has chunks with sizes increasing exponentially using >>> power of 2: 16, 16, 32, 64, 128, 256, 512, ... Each chunk has capacity >>> equal to the sum of capacities of all previous chunks. So nearly optimal >>> split (modulo last non-full chunk) would be to always split so that the >>> last chunk is cut-off and the returned Spliterator contains all the >>> chunks up to the last and this Spliterator only contains the last chunk. >>> >>> Here's my attempt at modifying the spliterator to act like that (I only >>> did it for the generic Object variant in 1st try, but I can prepare the >>> primitive variants too, if desired): >>> >>> http://dl.dropboxusercontent.com/u/101777488/jdk8-lambda/SpinedBufferAltSpliterator/webrev.01/index.html >>> >>> >>> >>> >>> With this modification, the above code prints: >>> >>> 16384: split 8192 + 8192 >>> 8192: split 4096 + 4096 >>> 4096: split 2048 + 2048 >>> 2048: split 1024 + 1024 >>> 1024: (0...1023) >>> 1024: (1024...2047) >>> 2048: split 1024 + 1024 >>> 1024: (2048...3071) >>> 1024: (3072...4095) >>> 4096: split 2048 + 2048 >>> 2048: split 1024 + 1024 >>> 1024: (4096...5119) >>> 1024: (5120...6143) >>> 2048: split 1024 + 1024 >>> 1024: (6144...7167) >>> 1024: (7168...8191) >>> 8192: split 4096 + 4096 >>> 4096: split 2048 + 2048 >>> 2048: split 1024 + 1024 >>> 1024: (8192...9215) >>> 1024: (9216...10239) >>> 2048: split 1024 + 1024 >>> 1024: (10240...11263) >>> 1024: (11264...12287) >>> 4096: split 2048 + 2048 >>> 2048: split 1024 + 1024 >>> 1024: (12288...13311) >>> 1024: (13312...14335) >>> 2048: split 1024 + 1024 >>> 1024: (14336...15359) >>> 1024: (15360...16383) >>> >>> Total leafs: 16 >>> >>> >>> Regards, Peter >>> > > From paul.sandoz at oracle.com Mon Jun 10 00:57:00 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Mon, 10 Jun 2013 09:57:00 +0200 Subject: Fwd: Loose end: zip References: <51B0E7B1.70008@oracle.com> Message-ID: Hi, If anyone has experimented with Streams.zip can you provide some feedback? see email below for context. Paul. Begin forwarded message: > From: Brian Goetz > Subject: Loose end: zip > Date: June 6, 2013 9:49:05 PM GMT+02:00 > To: Joe Bowbeer > Cc: "lambda-libs-spec-experts at openjdk.java.net" > Reply-To: lambda-libs-spec-observers at openjdk.java.net > > Still feeling kind of YAGNI on zip, for the reasons cited in the message below, plus: > - No primitive versions (would require new SAMs) > - Hard to parallelize > - Multiple ways to deal with streams of different length; we pick one > > Might this be something best provided by some other library than the JDK? Or as a code example somewhere people can crib from to roll their own? > > On 5/1/2013 5:10 PM, Brian Goetz wrote: >> Right, but the question is, how badly can we implement it and have it >> not be worse than nothing? And, with the current performance >> characteristics (new object per element), are we below that threshold? >> >> My problem is the same as with flatMap -- these are idioms from other >> languages that *translate poorly* to Java because of the lack of tuples >> and other structural types. (The flatMap we got left with -- which I >> reluctantly supported as the lesser of evils -- is, coincidentally, the >> only other stream operation that has allocation-per-element.) At what >> level of translation-fidelity loss do we say "yeah, it works great in >> that other environment, but too much is lost in translation"? >> >> I don't doubt the utility of zip, or the fact that Joe-alikes will want >> it, and would be bummed to not find it. My question is whether the >> crappy zip we can have is better than no zip. (Where better doesn't >> just mean "better than nothing", but carries its weight.) From peter.levart at gmail.com Sun Jun 9 08:24:23 2013 From: peter.levart at gmail.com (Peter Levart) Date: Sun, 09 Jun 2013 17:24:23 +0200 Subject: IncompatibleClassChangeError example Message-ID: <51B49E27.7090300@gmail.com> Hi, When I compile and run the following program with the latest tip of lambda repo: import java.util.function.Function; import java.util.function.Supplier; public class ICCEBug { interface Value extends Supplier { default Value map(Function mapper) { return new SuppliedValue<>(() -> mapper.apply(this.get())); } } static class SuppliedValue implements Value { private final Supplier supplier; SuppliedValue(Supplier supplier) { this.supplier = supplier; } @Override public T get() { return supplier.get(); } } public static void main(String[] args) { Value name = () -> "Peter"; Value sentence = name.map(nm -> "Hello " + nm + "!"); System.out.println(sentence.get()); } } ... I get the following exception: Exception in thread "main" java.lang.IncompatibleClassChangeError: Class ICCEBug$$Lambda$2 does not implement the requested interface ICCEBug$Value at ICCEBug$Value.lambda$0(ICCEBug.java:17) at ICCEBug$Value$$Lambda$3.get(Unknown Source) at ICCEBug$SuppliedValue.get(ICCEBug.java:30) at ICCEBug.main(ICCEBug.java:37) It looks like something is not compiled correctly. Regards, Peter From brian.goetz at oracle.com Mon Jun 10 13:26:47 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Mon, 10 Jun 2013 20:26:47 +0000 Subject: hg: lambda/lambda/jdk: Update spec on Arrays.parallelPrefix Message-ID: <20130610202708.CA92048108@hg.openjdk.java.net> Changeset: 57a134ffd989 Author: briangoetz Date: 2013-06-10 16:26 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/57a134ffd989 Update spec on Arrays.parallelPrefix Contributed-by: chegar ! src/share/classes/java/util/Arrays.java From forax at univ-mlv.fr Tue Jun 11 05:54:48 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Tue, 11 Jun 2013 14:54:48 +0200 Subject: Hiding the lambda proxy frame Message-ID: <51B71E18.7020501@univ-mlv.fr> Hi Brian, Paul, Robert, hi all, currently when you print a stacktrace that show a call inside a lambda, users can see the the frame corresponding to the method of the generated proxy. By example: java.lang.Throwable StackTraceTest.lambda$0(StackTraceTest.java:6) StackTraceTest$$Lambda$1.run(Unknown Source) <--- ugly, isn't it StackTraceTest.main(StackTraceTest.java:8) I think this line should not be visible to user, it doesn't provide useful information, just make the stack trace longer than it should. A method can be marked hidden in a stack trace by using the annotation LambdaFom.Hidden. With ASM, one just have to add the following line: mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true); cheers, R?mi From richard.warburton at gmail.com Tue Jun 11 06:59:51 2013 From: richard.warburton at gmail.com (Richard Warburton) Date: Tue, 11 Jun 2013 14:59:51 +0100 Subject: Loose end: zip In-Reply-To: References: <51B0E7B1.70008@oracle.com> Message-ID: Hi, If anyone has experimented with Streams.zip can you provide some feedback? > see email below for context. > Thanks for asking ;) > Still feeling kind of YAGNI on zip, for the reasons cited in the message > below, plus: > > - No primitive versions (would require new SAMs) > > - Hard to parallelize > > - Multiple ways to deal with streams of different length; we pick one > > > > Might this be something best provided by some other library than the > JDK? Or as a code example somewhere people can crib from to roll their own? > > > > On 5/1/2013 5:10 PM, Brian Goetz wrote: > >> Right, but the question is, how badly can we implement it and have it > >> not be worse than nothing? And, with the current performance > >> characteristics (new object per element), are we below that threshold? > >> > >> My problem is the same as with flatMap -- these are idioms from other > >> languages that *translate poorly* to Java because of the lack of tuples > >> and other structural types. (The flatMap we got left with -- which I > >> reluctantly supported as the lesser of evils -- is, coincidentally, the > >> only other stream operation that has allocation-per-element.) At what > >> level of translation-fidelity loss do we say "yeah, it works great in > >> that other environment, but too much is lost in translation"? > >> > >> I don't doubt the utility of zip, or the fact that Joe-alikes will want > >> it, and would be bummed to not find it. My question is whether the > >> crappy zip we can have is better than no zip. (Where better doesn't > >> just mean "better than nothing", but carries its weight.) The things that I've come across where Streams.zip is appropriate are all fairly mathematical in nature: - vector dot product - signal convolution - cross-correlation + auto-correlation - finite impulse response filters - discrete-time fourier transform The last 4 examples are all situations in which people do generally care about the implementation's performance, rather than being willing to pay a cost in favour of abstraction. They are also situations in which you want primitives, rather than boxed numerical values. Furthermore convolution, cross-correlation of them are implementable in terms of the fourier transform and auto-correlation in terms of cross-correlation. So I guess my usage of Streams.zip suggests that a slow, boxed only, version wouldn't actually be used to implement the algorithms that its useful for. There's certainly user demand for it though. Before zip was added we did have several people ask about zip at lambdas hackdays. Sadly I failed to ask them why and what their motivation was. Sorry about that. Its almost inevitable that if you leave it out that people will be asking the question "why is there no zip or zipWith in Java?" until the end of time in the same way that people ask about tuples until the end of time. regards, Dr. Richard Warburton http://insightfullogic.com @RichardWarburto From Robert.Field at oracle.com Tue Jun 11 08:01:58 2013 From: Robert.Field at oracle.com (Robert Field) Date: Tue, 11 Jun 2013 08:01:58 -0700 Subject: Hiding the lambda proxy frame In-Reply-To: <51B71E18.7020501@univ-mlv.fr> References: <51B71E18.7020501@univ-mlv.fr> Message-ID: <51B73BE6.2060402@oracle.com> Good point. I have submitted 8016334: Hide the lambda proxy frame And assigned it to myself. Thanks, Robert On 6/11/13 5:54 AM, Remi Forax wrote: > Hi Brian, Paul, Robert, hi all, > currently when you print a stacktrace that show a call inside a lambda, > users can see the the frame corresponding to the method of the generated > proxy. > > By example: > java.lang.Throwable > StackTraceTest.lambda$0(StackTraceTest.java:6) > StackTraceTest$$Lambda$1.run(Unknown Source) <--- ugly, isn't it > StackTraceTest.main(StackTraceTest.java:8) > > I think this line should not be visible to user, it doesn't provide > useful information, > just make the stack trace longer than it should. > > A method can be marked hidden in a stack trace by using the annotation > LambdaFom.Hidden. > > With ASM, one just have to add the following line: > > mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true); > > cheers, > R?mi > > From forax at univ-mlv.fr Tue Jun 11 09:56:19 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Tue, 11 Jun 2013 18:56:19 +0200 Subject: Hiding the lambda proxy frame In-Reply-To: <51B73BE6.2060402@oracle.com> References: <51B71E18.7020501@univ-mlv.fr> <51B73BE6.2060402@oracle.com> Message-ID: <51B756B3.4080509@univ-mlv.fr> On 06/11/2013 05:01 PM, Robert Field wrote: > Good point. > I have submitted 8016334: Hide the lambda proxy frame > And assigned it to myself. > > Thanks, > Robert Thank you Robert, Brian remind me that because this annotation is currently Hotspot specific, we have to made it public first and part of the JDK (either as a top-level annotation in java.lang.invoke or as inner in java.lang.invoke.LambdaMetaFactory). R?mi > > On 6/11/13 5:54 AM, Remi Forax wrote: >> Hi Brian, Paul, Robert, hi all, >> currently when you print a stacktrace that show a call inside a lambda, >> users can see the the frame corresponding to the method of the generated >> proxy. >> >> By example: >> java.lang.Throwable >> StackTraceTest.lambda$0(StackTraceTest.java:6) >> StackTraceTest$$Lambda$1.run(Unknown Source) <--- ugly, isn't it >> StackTraceTest.main(StackTraceTest.java:8) >> >> I think this line should not be visible to user, it doesn't provide >> useful information, >> just make the stack trace longer than it should. >> >> A method can be marked hidden in a stack trace by using the annotation >> LambdaFom.Hidden. >> >> With ASM, one just have to add the following line: >> >> mv.visitAnnotation("Ljava/lang/invoke/LambdaForm$Hidden;", true); >> >> cheers, >> R?mi >> >> > From henry.jen at oracle.com Tue Jun 11 14:04:38 2013 From: henry.jen at oracle.com (Henry Jen) Date: Tue, 11 Jun 2013 14:04:38 -0700 Subject: RFR 8009736: Comparator API cleanup Message-ID: <51B790E6.6020209@oracle.com> Hi, Please review http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/webrev/ Highlight of changes, - Comparators class is now only package-private implementations. The public static methods have been move to other arguably more appropriate places, mostly in Comparator. - Comparator.reverseOrder() is renamed to Comparator.reversed() - nullsFirst(Comparator) and nullsLast(Comparator) are introduced to wrap up a comparator to be null-friendly. To see the API changes, found the specdiff at http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/specdiff/overview-summary.html Cheers, Henry From forax at univ-mlv.fr Tue Jun 11 14:20:57 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Tue, 11 Jun 2013 23:20:57 +0200 Subject: LineNumber Message-ID: <51B794B9.7000509@univ-mlv.fr> Hi Maurizio, hi guys, Jamie Allen (from typesafe) has found an example of code where the line number are not correctly generated. import java.util.List; import java.util.Arrays; import java.util.stream.Collectors; public class LambdaDemo { public static void main(String... args) { final List numbers = Arrays.asList(1, 2, 3); final List numbersPlusOne = numbers.stream().map(number -> number / 0).collect(Collectors.toList()); } } Exception in thread "main" java.lang.ArithmeticException: / by zero at LambdaDemo.lambda$0(LambdaDemo.java:1) <-- oops at LambdaDemo$$Lambda$1.apply(Unknown Source) at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:188) at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948) at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:467) at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:457) at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:710) at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:231) at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:474) at LambdaDemo.main(LambdaDemo.java:10) cheers, R?mi From paul.sandoz at oracle.com Wed Jun 12 05:13:50 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Wed, 12 Jun 2013 12:13:50 +0000 Subject: hg: lambda/lambda/jdk: Tests for Node.OfXxx.truncate. Message-ID: <20130612121413.3164148180@hg.openjdk.java.net> Changeset: 82c52cbb2b99 Author: psandoz Date: 2013-06-12 14:11 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/82c52cbb2b99 Tests for Node.OfXxx.truncate. ! test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java ! test/java/util/stream/boottest/java/util/stream/IntNodeTest.java ! test/java/util/stream/boottest/java/util/stream/LongNodeTest.java From paul.sandoz at oracle.com Wed Jun 12 06:01:11 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Wed, 12 Jun 2013 13:01:11 +0000 Subject: hg: lambda/lambda/jdk: Fix header. Message-ID: <20130612130124.B866648186@hg.openjdk.java.net> Changeset: f9074fec6bfa Author: psandoz Date: 2013-06-12 15:01 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f9074fec6bfa Fix header. ! test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java From paul.sandoz at oracle.com Wed Jun 12 05:18:30 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Wed, 12 Jun 2013 12:18:30 +0000 Subject: hg: lambda/lambda/jdk: Format line. Message-ID: <20130612121842.1994B48181@hg.openjdk.java.net> Changeset: bdabac9c6750 Author: psandoz Date: 2013-06-12 14:18 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bdabac9c6750 Format line. ! src/share/classes/java/util/stream/LongPipeline.java From paul.sandoz at oracle.com Wed Jun 12 06:07:52 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Wed, 12 Jun 2013 13:07:52 +0000 Subject: hg: lambda/lambda/jdk: Correct copywrite year. Message-ID: <20130612130804.D9BF748187@hg.openjdk.java.net> Changeset: 077464eec18c Author: psandoz Date: 2013-06-12 15:07 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/077464eec18c Correct copywrite year. ! test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java From paul.sandoz at oracle.com Wed Jun 12 07:18:09 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Wed, 12 Jun 2013 16:18:09 +0200 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51B790E6.6020209@oracle.com> References: <51B790E6.6020209@oracle.com> Message-ID: <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> Hi Henry, If you don't mind could you hold off on committing this one until the following have gone through to tl: http://cr.openjdk.java.net/~psandoz/tl/JDK-8016251-spinedBuffer-splitr/webrev/ http://cr.openjdk.java.net/~psandoz/tl/JDK-8016308-Node/webrev/ http://cr.openjdk.java.net/~psandoz/tl/JDK-8016324-pipelines/webrev/ http://cr.openjdk.java.net/~psandoz/tl/JDK-8016455-stream-tests/webrev/ as there is a delicate balance here to group the code into meaningful units for review and it's awkward to shuffle/update things. I rebased your patch off my patch queue, only one conflict required fixing. I can send you that queue in another email. Is that OK for you? -- Comparator.reverseOrder + *

The returned comparator is serializable. Try to compare null with + * returned comparator will throw {@link NullPointerException}. + * Typo "Try to compare" (and to . Do you mean: The compare method of the returned comparator will throw a {@link NullPointerException} if a {@code null} value is passed as the second parameter. ? Perhaps add a "@See Collections#reverseOrder" and vice versa on that method. Similar issue for Comparator.naturalOrder but for null passed as the first parameter. Comparators.comparing. Rather than "For example" you can use @apiNote .e.g * @apiNote * To obtain a .... The ToIntFunction accepting method has an example where as the long and double methods to not, perhaps just remove it. Comparators.NullComparator The "real" field can never be null: + NullComparator(int sign, Comparator real) { + this.sign = sign; + this.real = (Comparator) Objects.requireNonNull(real); + } but you are checking for null in the compare method + @Override + public int compare(T a, T b) { + if (a == null) { + return (b == null) ? 0 : sign; + } else if (b == null) { + return -sign; + } else { + return (real == null) ? 0 : real.compare(a, b); // <---- null check + } + } Map.comparingByKey/Value(Comparator cmp) You don't mention "Note that a null key/value..." test/java/util/Comparator/BasicTest.java test/java/util/Comparator/TypeTest.java Has the wrong license header: + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. should be: + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Thanks, Paul. On Jun 11, 2013, at 11:04 PM, Henry Jen wrote: > Hi, > > Please review http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/webrev/ > > Highlight of changes, > > - Comparators class is now only package-private implementations. The > public static methods have been move to other arguably more appropriate > places, mostly in Comparator. > > - Comparator.reverseOrder() is renamed to Comparator.reversed() > > - nullsFirst(Comparator) and nullsLast(Comparator) are introduced to > wrap up a comparator to be null-friendly. > > To see the API changes, found the specdiff at > http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/specdiff/overview-summary.html > > Cheers, > Henry From henry.jen at Oracle.com Wed Jun 12 08:54:28 2013 From: henry.jen at Oracle.com (Henry Jen) Date: Wed, 12 Jun 2013 08:54:28 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> Message-ID: <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> On Jun 12, 2013, at 7:18 AM, Paul Sandoz wrote: > Hi Henry, > > If you don't mind could you hold off on committing this one until the following have gone through to tl: > > http://cr.openjdk.java.net/~psandoz/tl/JDK-8016251-spinedBuffer-splitr/webrev/ > http://cr.openjdk.java.net/~psandoz/tl/JDK-8016308-Node/webrev/ > http://cr.openjdk.java.net/~psandoz/tl/JDK-8016324-pipelines/webrev/ > http://cr.openjdk.java.net/~psandoz/tl/JDK-8016455-stream-tests/webrev/ > > as there is a delicate balance here to group the code into meaningful units for review and it's awkward to shuffle/update things. > > I rebased your patch off my patch queue, only one conflict required fixing. I can send you that queue in another email. Is that OK for you? > Sure. > -- > > Comparator.reverseOrder > > + *

The returned comparator is serializable. Try to compare null with > + * returned comparator will throw {@link NullPointerException}. > + * > > Typo "Try to compare" (and to . Do you mean: > > The compare method of the returned comparator will throw a {@link NullPointerException} if a {@code null} value is passed as the second parameter. > > ? > > Perhaps add a "@See Collections#reverseOrder" and vice versa on that method. > > Similar issue for Comparator.naturalOrder but for null passed as the first parameter. > Is "compare null using" better then "compare null with"? null passed as an argument will cause NPE on returned comparator, regardless position. > > Comparators.comparing. > > Rather than "For example" you can use @apiNote .e.g > > * @apiNote > * To obtain a .... > > The ToIntFunction accepting method has an example where as the long and double methods to not, perhaps just remove it. > Make sense. I have #see for comparing(Function), should be clear enough. > > Comparators.NullComparator > > The "real" field can never be null: > > + NullComparator(int sign, Comparator real) { > + this.sign = sign; > + this.real = (Comparator) Objects.requireNonNull(real); > + } > > but you are checking for null in the compare method > > + @Override > + public int compare(T a, T b) { > + if (a == null) { > + return (b == null) ? 0 : sign; > + } else if (b == null) { > + return -sign; > + } else { > + return (real == null) ? 0 : real.compare(a, b); // <---- null check > + } > + } > Hmm, I missed this one. Thanks. > > Map.comparingByKey/Value(Comparator cmp) > > You don't mention "Note that a null key/value?" > That's because null is handled by Comparator in this case, if the Comparator is null-friendly, it is fine. Perhaps I should make that clear. > > test/java/util/Comparator/BasicTest.java > test/java/util/Comparator/TypeTest.java > > Has the wrong license header: > > + * This code is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License version 2 only, as > + * published by the Free Software Foundation. Oracle designates this > + * particular file as subject to the "Classpath" exception as provided > + * by Oracle in the LICENSE file that accompanied this code. > > should be: > > + * This code is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License version 2 only, as > + * published by the Free Software Foundation. > WIll fix. Thanks for review. Cheers, Henry From paul.sandoz at oracle.com Wed Jun 12 09:36:59 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Wed, 12 Jun 2013 18:36:59 +0200 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> Message-ID: <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> On Jun 12, 2013, at 5:54 PM, Henry Jen wrote: >> >> Comparator.reverseOrder >> >> + *

The returned comparator is serializable. Try to compare null with >> + * returned comparator will throw {@link NullPointerException}. >> + * >> >> Typo "Try to compare" (and to . Do you mean: >> >> The compare method of the returned comparator will throw a {@link NullPointerException} if a {@code null} value is passed as the second parameter. >> >> ? >> >> Perhaps add a "@See Collections#reverseOrder" and vice versa on that method. >> >> Similar issue for Comparator.naturalOrder but for null passed as the first parameter. >> > > Is "compare null using" better then "compare null with"? > It's more the tense of the sentence. How about: "The returned comparator is serializable and does not permit null arguments when comparing objects". ? > null passed as an argument will cause NPE on returned comparator, regardless position. > Doh!, of course :-) Comparable.compare(null) should also throw an NPE, just the stack trace will be slightly different. >> Map.comparingByKey/Value(Comparator cmp) >> >> You don't mention "Note that a null key/value?" >> > > That's because null is handled by Comparator in this case, if the Comparator is null-friendly, it is fine. Perhaps I should make that clear. Ah, yes, some clarification would be useful. Paul. From per at bothner.com Wed Jun 12 10:23:26 2013 From: per at bothner.com (Per Bothner) Date: Wed, 12 Jun 2013 10:23:26 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51B790E6.6020209@oracle.com> References: <51B790E6.6020209@oracle.com> Message-ID: <51B8AE8E.6020703@bothner.com> You might find interesting this proposal for "big" Scheme. It views a "comparator" as a bundle consisting of an (optional) comparator function, along with optional hash function, equality function, and type-check function. http://trac.sacrideo.us/wg/wiki/ComparatorsCowan Using a more general "comparator bundle" can be convenient at times. For example when constructing a hash table it is useful to pass the equality function and the hash function as single object. (Of course you normally don't use the compare functions in those cases.) If the ComparatorsCowan becomes part of Scheme, I'd probably implement it as a class that implements java.util.Comparator, at least for bundles that have an actual compare function. -- --Per Bothner per at bothner.com http://per.bothner.com/ From boaznahum at gmail.com Wed Jun 12 12:20:15 2013 From: boaznahum at gmail.com (Boaz Nahum) Date: Wed, 12 Jun 2013 22:20:15 +0300 Subject: reference to comparing is ambiguous & inference loop Message-ID: I built lambda/lambda today class TestResult { public double getRank() { ... } } List results = .. results.sort(Comparator.comparing(TestResult::getRank)); Got this error: java: reference to comparing is ambiguous both method comparing(java.util.function.ToLongFunction) in java.util.Comparator and method comparing(java.util.function.ToDoubleFunction) in java.util.Comparator match java: incompatible types: Cannot instantiate inference variables T because of an inference loop Any way to get around this ? Thanks Boaz From henry.jen at oracle.com Wed Jun 12 12:49:13 2013 From: henry.jen at oracle.com (Henry Jen) Date: Wed, 12 Jun 2013 12:49:13 -0700 Subject: reference to comparing is ambiguous & inference loop In-Reply-To: References: Message-ID: On Jun 12, 2013, at 12:20 PM, Boaz Nahum wrote: > I built lambda/lambda today > > > > class TestResult { > public double getRank() { ... } > } > > List results = .. > results.sort(Comparator.comparing(TestResult::getRank)); > > Got this error: > java: reference to comparing is ambiguous > both method comparing(java.util.function.ToLongFunction) in > java.util.Comparator and method > comparing(java.util.function.ToDoubleFunction) in > java.util.Comparator match > > java: incompatible types: Cannot instantiate inference variables T because > of an inference loop > > > Any way to get around this ? > Compiler is looking to improve this, add a cast for now. (ToDoubleFunction) TestResult::getRank. Cheers, Henry From brian.goetz at oracle.com Wed Jun 12 13:19:01 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Wed, 12 Jun 2013 20:19:01 +0000 Subject: hg: lambda/lambda/jdk: Act on review comments and EG feedback on Optional Message-ID: <20130612201929.A2A4C4819F@hg.openjdk.java.net> Changeset: 84b9dbfc21fa Author: briangoetz Date: 2013-06-12 16:18 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/84b9dbfc21fa Act on review comments and EG feedback on Optional ! src/share/classes/java/util/Optional.java From boaznahum at gmail.com Wed Jun 12 21:07:24 2013 From: boaznahum at gmail.com (Boaz Nahum) Date: Thu, 13 Jun 2013 07:07:24 +0300 Subject: reference to comparing is ambiguous & inference loop In-Reply-To: References: Message-ID: Isn't comparingDouble shorter? Thanks Boaz On Jun 12, 2013 10:49 PM, "Henry Jen" wrote: > On Jun 12, 2013, at 12:20 PM, Boaz Nahum wrote: > > > I built lambda/lambda today > > > > > > > > class TestResult { > > public double getRank() { ... } > > } > > > > List results = .. > > results.sort(Comparator.comparing(TestResult::getRank)); > > > > Got this error: > > java: reference to comparing is ambiguous > > both method comparing(java.util.function.ToLongFunction) > in > > java.util.Comparator and method > > comparing(java.util.function.ToDoubleFunction) in > > java.util.Comparator match > > > > java: incompatible types: Cannot instantiate inference variables T > because > > of an inference loop > > > > > > Any way to get around this ? > > > > Compiler is looking to improve this, add a cast for now. > > (ToDoubleFunction) TestResult::getRank. > > Cheers, > Henry > > From zhong.j.yu at gmail.com Wed Jun 12 22:33:25 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Thu, 13 Jun 2013 00:33:25 -0500 Subject: Collection.toArray(IntFunction) In-Reply-To: References: <51A6FFFD.80707@gmail.com> Message-ID: On Thu, May 30, 2013 at 3:14 AM, Stephen Colebourne wrote: > On 30 May 2013 08:30, Peter Levart wrote: >> String[] y = x.toArray(String[]::new); > > Thats very nice ;-) > Stephen > Hmm... toArray(new String[0]) toArray(String[]::new) not too much difference in syntax. Try to explain it to a newbie:) I wish we could have something like this: interface Collection { @SafeVarargs E[] array(E... array); } Collection x = ...; x.array(); This works because an empty String[] is passed in as the arg. Zhong Yu From henry.jen at oracle.com Wed Jun 12 23:53:41 2013 From: henry.jen at oracle.com (Henry Jen) Date: Wed, 12 Jun 2013 23:53:41 -0700 Subject: reference to comparing is ambiguous & inference loop In-Reply-To: References: Message-ID: <59F408B2-4E62-46E9-8B13-25EC9F652A95@oracle.com> On Jun 12, 2013, at 9:07 PM, Boaz Nahum wrote: > Isn't comparingDouble shorter? > > We are working to get rid of the cast for most common cases, method reference for example. Cheers, Henry > Thanks > Boaz > > On Jun 12, 2013 10:49 PM, "Henry Jen" wrote: > On Jun 12, 2013, at 12:20 PM, Boaz Nahum wrote: > > > I built lambda/lambda today > > > > > > > > class TestResult { > > public double getRank() { ... } > > } > > > > List results = .. > > results.sort(Comparator.comparing(TestResult::getRank)); > > > > Got this error: > > java: reference to comparing is ambiguous > > both method comparing(java.util.function.ToLongFunction) in > > java.util.Comparator and method > > comparing(java.util.function.ToDoubleFunction) in > > java.util.Comparator match > > > > java: incompatible types: Cannot instantiate inference variables T because > > of an inference loop > > > > > > Any way to get around this ? > > > > Compiler is looking to improve this, add a cast for now. > > (ToDoubleFunction) TestResult::getRank. > > Cheers, > Henry > From forax at univ-mlv.fr Thu Jun 13 00:09:23 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Thu, 13 Jun 2013 09:09:23 +0200 Subject: Collection.toArray(IntFunction) In-Reply-To: References: <51A6FFFD.80707@gmail.com> Message-ID: <51B97023.8020102@univ-mlv.fr> On 06/13/2013 07:33 AM, Zhong Yu wrote: > On Thu, May 30, 2013 at 3:14 AM, Stephen Colebourne > wrote: >> On 30 May 2013 08:30, Peter Levart wrote: >>> String[] y = x.toArray(String[]::new); >> Thats very nice ;-) >> Stephen >> > Hmm... > toArray(new String[0]) > toArray(String[]::new) > not too much difference in syntax. Try to explain it to a newbie:) Apart from the coloncolon syntax (::), it's easy either you give the size or not. > > I wish we could have something like this: > > interface Collection > { > @SafeVarargs > E[] array(E... array); > } > > Collection x = ...; > x.array(); > > This works because an empty String[] is passed in as the arg. Without discussing about the restrictions on @SafeVarargs, It depends what you mean by it works, if it's apart creating a big hole in the type safety of all programs because this method allows to create arrays of parametrized types which are unsafe, I agree with you, it works :) > > Zhong Yu > R?mi From peter.levart at gmail.com Thu Jun 13 04:16:59 2013 From: peter.levart at gmail.com (Peter Levart) Date: Thu, 13 Jun 2013 13:16:59 +0200 Subject: BiIterable? Message-ID: <51B9AA2B.5010606@gmail.com> With the advent of new functional types in java.util.function and new default method Map.forEach(), I wonder if it has been considered to add the following interface to standard library: public interface BiIterable { void forEach(BiConsumer action); } Which could be used as a super-interface for Map: public interface Map extends BiIterable { ... ... in analogous way that Iterable is super-interface of Collection. Iterable supports external iteration from day one, and now it also supports internal iteration by the way of default method with optimized implementations in JDK classes that show improved performance. For BiIterable internal iteration is actually the only alternative, since it avoids boxing of arguments into a Pair. What do you think? Regards, Peter From ali.ebrahimi1781 at gmail.com Thu Jun 13 05:40:07 2013 From: ali.ebrahimi1781 at gmail.com (Ali Ebrahimi) Date: Thu, 13 Jun 2013 17:10:07 +0430 Subject: BiIterable? In-Reply-To: <51B9AA2B.5010606@gmail.com> References: <51B9AA2B.5010606@gmail.com> Message-ID: what about Iterable>: public interface Map extends Iterable> { default Iterator> iterator(){...} . } with Iterable> internal iteration is not the only alternative, because you can now for(Entry e:map) if we move stream and parallelStream methods to Iterable we can utilize from stream framework: map.stream().filter( e -> e.getKey().contains("somePattern")).map(e -> e.getValue()).... What others think about this. On Thu, Jun 13, 2013 at 3:46 PM, Peter Levart wrote: > With the advent of new functional types in java.util.function and new > default method Map.forEach(), I wonder if it has been considered to add > the following interface to standard library: > > public interface BiIterable { > void forEach(BiConsumer action); > } > > > Which could be used as a super-interface for Map: > > public interface Map extends BiIterable { ... > > > ... in analogous way that Iterable is super-interface of Collection. > > Iterable supports external iteration from day one, and now it also > supports internal iteration by the way of default method with optimized > implementations in JDK classes that show improved performance. For > BiIterable internal iteration is actually the only alternative, > since it avoids boxing of arguments into a Pair. > > > What do you think? > > Regards, Peter > > > From howard.lovatt at gmail.com Thu Jun 13 05:42:09 2013 From: howard.lovatt at gmail.com (Howard Lovatt) Date: Thu, 13 Jun 2013 22:42:09 +1000 Subject: BiIterable? In-Reply-To: <51B9AA2B.5010606@gmail.com> References: <51B9AA2B.5010606@gmail.com> Message-ID: <3A6607A3-A487-4282-9D94-0881283A768D@gmail.com> +1 Sent from my iPad On 13/06/2013, at 9:16 PM, Peter Levart wrote: > With the advent of new functional types in java.util.function and new > default method Map.forEach(), I wonder if it has been considered to add > the following interface to standard library: > > public interface BiIterable { > void forEach(BiConsumer action); > } > > > Which could be used as a super-interface for Map: > > public interface Map extends BiIterable { ... > > > ... in analogous way that Iterable is super-interface of Collection. > > Iterable supports external iteration from day one, and now it also > supports internal iteration by the way of default method with optimized > implementations in JDK classes that show improved performance. For > BiIterable internal iteration is actually the only alternative, > since it avoids boxing of arguments into a Pair. > > > What do you think? > > Regards, Peter > > From forax at univ-mlv.fr Thu Jun 13 05:45:13 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Thu, 13 Jun 2013 14:45:13 +0200 Subject: BiIterable? In-Reply-To: <51B9AA2B.5010606@gmail.com> References: <51B9AA2B.5010606@gmail.com> Message-ID: <51B9BED9.6060209@univ-mlv.fr> On 06/13/2013 01:16 PM, Peter Levart wrote: > With the advent of new functional types in java.util.function and new > default method Map.forEach(), I wonder if it has been considered to add > the following interface to standard library: > > public interface BiIterable { > void forEach(BiConsumer action); > } > > > Which could be used as a super-interface for Map: > > public interface Map extends BiIterable { ... > > > ... in analogous way that Iterable is super-interface of Collection. > > Iterable supports external iteration from day one, and now it also > supports internal iteration by the way of default method with optimized > implementations in JDK classes that show improved performance. For > BiIterable internal iteration is actually the only alternative, > since it avoids boxing of arguments into a Pair. > > > What do you think? BiIterable is a functional interface so one can write BiIterable biIterable = map::forEach; thus I don't think there is a need to put this interface in the JDK. > > Regards, Peter > > cheers, R?mi From howard.lovatt at gmail.com Thu Jun 13 05:50:09 2013 From: howard.lovatt at gmail.com (Howard Lovatt) Date: Thu, 13 Jun 2013 22:50:09 +1000 Subject: Collection.toArray(IntFunction) In-Reply-To: References: <51A6FFFD.80707@gmail.com> Message-ID: <426CF011-BBE2-4C1C-A29F-9843371AE202@gmail.com> You might as well return an Object array and cast it, E[] array() { E[] array = (E[])new Object[size()]; ...; return array; }, same thing as as var ags fudge does. Sent from my iPad On 13/06/2013, at 3:33 PM, Zhong Yu wrote: > On Thu, May 30, 2013 at 3:14 AM, Stephen Colebourne > wrote: >> On 30 May 2013 08:30, Peter Levart wrote: >>> String[] y = x.toArray(String[]::new); >> >> Thats very nice ;-) >> Stephen > > Hmm... > toArray(new String[0]) > toArray(String[]::new) > not too much difference in syntax. Try to explain it to a newbie:) > > I wish we could have something like this: > > interface Collection > { > @SafeVarargs > E[] array(E... array); > } > > Collection x = ...; > x.array(); > > This works because an empty String[] is passed in as the arg. > > Zhong Yu > From paul.sandoz at oracle.com Thu Jun 13 06:43:41 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 13 Jun 2013 13:43:41 +0000 Subject: hg: lambda/lambda/jdk: Improve slice spliterator tests. Message-ID: <20130613134450.4CE36481C5@hg.openjdk.java.net> Changeset: 298c84d21a3e Author: psandoz Date: 2013-06-13 15:43 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/298c84d21a3e Improve slice spliterator tests. Modify spliterator helper tests to support a content asserter such an the unordered slice spliterator can check that the slice spliterator content is a sub-set of the source. ! src/share/classes/java/util/stream/StreamSpliterators.java ! test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java ! test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java From peter.levart at gmail.com Thu Jun 13 07:07:58 2013 From: peter.levart at gmail.com (Peter Levart) Date: Thu, 13 Jun 2013 16:07:58 +0200 Subject: What happened to ConcurrentHashMap? In-Reply-To: <20130605224445.29D3548FD0@hg.openjdk.java.net> References: <20130605224445.29D3548FD0@hg.openjdk.java.net> Message-ID: <51B9D23E.8050803@gmail.com> On 06/06/2013 12:21 AM, mike.duigou at oracle.com wrote: > Changeset: 251c9524952b > Author: mduigou > Date: 2013-06-05 13:28 -0700 > URL:http://hg.openjdk.java.net/lambda/lambda/jdk/rev/251c9524952b > > Merge > > ! .hgtags > - .jcheck/conf > ! src/share/classes/java/lang/String.java > ! src/share/classes/java/lang/StringBuffer.java > ! src/share/classes/java/nio/file/FileTreeIterator.java > ! src/share/classes/java/nio/file/Files.java > ! src/share/classes/java/util/Arrays.java > ! src/share/classes/java/util/ArraysParallelSortHelpers.java > ! src/share/classes/java/util/ComparableTimSort.java > ! src/share/classes/java/util/DualPivotQuicksort.java > ! src/share/classes/java/util/Spliterator.java > ! src/share/classes/java/util/TimSort.java > ! src/share/classes/java/util/concurrent/ConcurrentHashMap.java ...Are Segments back? Where are all the goodies? Regards, Peter From peter.levart at gmail.com Thu Jun 13 07:26:01 2013 From: peter.levart at gmail.com (Peter Levart) Date: Thu, 13 Jun 2013 16:26:01 +0200 Subject: BiIterable? In-Reply-To: <51B9BED9.6060209@univ-mlv.fr> References: <51B9AA2B.5010606@gmail.com> <51B9BED9.6060209@univ-mlv.fr> Message-ID: <51B9D679.40308@gmail.com> On 06/13/2013 02:45 PM, Remi Forax wrote: >> >public interface BiIterable { >> > void forEach(BiConsumer action); >> >} >> > >> > >> >Which could be used as a super-interface for Map: >> > >> >public interface Map extends BiIterable { ... >> > >> > >> >... in analogous way that Iterable is super-interface of Collection. >> > > BiIterable is a functional interface so one can write > BiIterable biIterable = map::forEach; > > thus I don't think there is a need to put this interface in the JDK. > Ok, I agree. Regards, Peter From zhong.j.yu at gmail.com Thu Jun 13 07:40:47 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Thu, 13 Jun 2013 09:40:47 -0500 Subject: Collection.toArray(IntFunction) In-Reply-To: <51B97023.8020102@univ-mlv.fr> References: <51A6FFFD.80707@gmail.com> <51B97023.8020102@univ-mlv.fr> Message-ID: On Thu, Jun 13, 2013 at 2:09 AM, Remi Forax wrote: > On 06/13/2013 07:33 AM, Zhong Yu wrote: >> On Thu, May 30, 2013 at 3:14 AM, Stephen Colebourne >> wrote: >>> On 30 May 2013 08:30, Peter Levart wrote: >>>> String[] y = x.toArray(String[]::new); >>> Thats very nice ;-) >>> Stephen >>> >> Hmm... >> toArray(new String[0]) >> toArray(String[]::new) >> not too much difference in syntax. Try to explain it to a newbie:) > > Apart from the coloncolon syntax (::), it's easy either you give the > size or not. > >> >> I wish we could have something like this: >> >> interface Collection >> { >> @SafeVarargs >> E[] array(E... array); >> } >> >> Collection x = ...; >> x.array(); >> >> This works because an empty String[] is passed in as the arg. > > Without discussing about the restrictions on @SafeVarargs, It depends > what you mean by it works, if it's apart creating a big hole in the type > safety of all programs because this method allows to create arrays of > parametrized types which are unsafe, I agree with you, it works :) I think creating generic arrays is safe, as safe as instantiating generic Lists; what is unsafe is up-casting generic arrays in a way that loses type arguments, e.g. List[] -> List[]. Java should allow the 1st case, and raise a warning for the 2nd case. Zhong Yu From peter.levart at gmail.com Thu Jun 13 07:47:36 2013 From: peter.levart at gmail.com (Peter Levart) Date: Thu, 13 Jun 2013 16:47:36 +0200 Subject: forEach/forEachOrdered/forEachRemaining ... iterate? Message-ID: <51B9DB88.5000107@gmail.com> I know it's a little late, but let's look at current situation. There are 5 methods in current APIs with similar names and signatures + 1 additional with a little different signature in Map + some similarly named methods in ConcurrentHashMap: interface Stream { void forEach(Consumer action) void forEachOrdered(Consumer action) } interface Iterable { void forEach(Consumer action) } interface Iterator { void forEachRemaining(Consumer action) } interface Spliterator { void forEachRemaining(Consumer action) } interface Map { void forEach(BiConsumer action) } class ConcurrentHashMap ... { void forEachKey(long parallelismThreshold, Consumer action) void forEachKey(long parallelismThreshold, Function transformer, Consumer action) void forEachValue(long parallelismThreshold, Consumer action) void forEachValue(long parallelismThreshold, Function transformer, Consumer action) } I'm wondering if the following alternative would be easier to read and reason-about in code: interface Stream { void forEach(Consumer action) void iterate(Consumer action) } interface Iterable { void iterate(Consumer action) } interface Iterator { void iterateRemaining(Consumer action) } interface Spliterator { void iterateRemaining(Consumer action) } interface Map { void iterate(BiConsumer action) } class ConcurrentHashMap ... { void forEachKey(long parallelismThreshold, Consumer action) void forEachKey(long parallelismThreshold, Function transformer, Consumer action) void forEachValue(long parallelismThreshold, Consumer action) void forEachValue(long parallelismThreshold, Function transformer, Consumer action) } Why? I'm a little concerned about the duality of Stream.forEach() and Iterable.forEach(). While the later is always sequential and encounter-ordered, the former can be executed out-of order and/or in-parallel. I think that by naming the sequential variants differently, the reader of code need not be concerned about the type of the target that the method is invoked upon, just the name. This enables fast browsing of code where the eye can quickly glance over iterate()s but slows down on each forEach()... How do others feel about the (re)use of forEach... names in different APIs? Would it be more difficult to find the right method if iterate() was used instead of forEach() for iteration? Regards, Peter From abies at adres.pl Thu Jun 13 07:57:50 2013 From: abies at adres.pl (Artur Biesiadowski) Date: Thu, 13 Jun 2013 16:57:50 +0200 Subject: BiIterable? In-Reply-To: References: <51B9AA2B.5010606@gmail.com> Message-ID: <51B9DDEE.90704@adres.pl> On 13/06/2013 14:40, Ali Ebrahimi wrote: > what about Iterable>: > > public interface Map extends Iterable> { > default Iterator> iterator(){...} > . > > } > > with Iterable> internal iteration is not the only alternative, > because you can now > > for(Entry e:map) > > if we move stream and parallelStream methods to Iterable we can utilize > from stream framework: > map.stream().filter( e -> e.getKey().contains("somePattern")).map(e -> > e.getValue()).... > Some map implementations (fast ones mostly...) don't use Entry internally, so they have either to create a new one on each .next() or break a contract a bit and reuse same one over and over, hoping nobody will cache them (and that they are not used in parallel environment like your example above). I don't suppose there is a way to do map.stream().filter(k,v -> e.contains("somePattern")).map(k,v -> v) ? Regards, Artur Biesiadowski From zhong.j.yu at gmail.com Thu Jun 13 08:03:17 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Thu, 13 Jun 2013 10:03:17 -0500 Subject: BiIterable? In-Reply-To: <51B9AA2B.5010606@gmail.com> References: <51B9AA2B.5010606@gmail.com> Message-ID: On Thu, Jun 13, 2013 at 6:16 AM, Peter Levart wrote: > With the advent of new functional types in java.util.function and new > default method Map.forEach(), I wonder if it has been considered to add > the following interface to standard library: > > public interface BiIterable { > void forEach(BiConsumer action); > } > > > Which could be used as a super-interface for Map: > > public interface Map extends BiIterable { ... > > > ... in analogous way that Iterable is super-interface of Collection. > > Iterable supports external iteration from day one, and now it also > supports internal iteration by the way of default method with optimized > implementations in JDK classes that show improved performance. For > BiIterable internal iteration is actually the only alternative, > since it avoids boxing I don't think we should be overly obsessed with avoiding object creation at the cost of extremely ugly APIs. > of arguments into a Pair. I wish Java could get a Pair. The arguments against Pair don't make any more sense than arguments against int or String. Or BiSomething - you can't say Pair is bad, but Bi is good, both words mean two-ness. Zhong Yu From peter.levart at gmail.com Thu Jun 13 08:04:59 2013 From: peter.levart at gmail.com (Peter Levart) Date: Thu, 13 Jun 2013 17:04:59 +0200 Subject: What happened to ConcurrentHashMap? In-Reply-To: <51B9D23E.8050803@gmail.com> References: <20130605224445.29D3548FD0@hg.openjdk.java.net> <51B9D23E.8050803@gmail.com> Message-ID: <51B9DF9B.30004@gmail.com> On 06/13/2013 04:07 PM, Peter Levart wrote: > On 06/06/2013 12:21 AM, mike.duigou at oracle.com wrote: >> Changeset: 251c9524952b >> Author: mduigou >> Date: 2013-06-05 13:28 -0700 >> URL:http://hg.openjdk.java.net/lambda/lambda/jdk/rev/251c9524952b >> >> Merge >> >> ! .hgtags >> - .jcheck/conf >> ! src/share/classes/java/lang/String.java >> ! src/share/classes/java/lang/StringBuffer.java >> ! src/share/classes/java/nio/file/FileTreeIterator.java >> ! src/share/classes/java/nio/file/Files.java >> ! src/share/classes/java/util/Arrays.java >> ! src/share/classes/java/util/ArraysParallelSortHelpers.java >> ! src/share/classes/java/util/ComparableTimSort.java >> ! src/share/classes/java/util/DualPivotQuicksort.java >> ! src/share/classes/java/util/Spliterator.java >> ! src/share/classes/java/util/TimSort.java >> ! src/share/classes/java/util/concurrent/ConcurrentHashMap.java > > ...Are Segments back? Where are all the goodies? > > Regards, Peter > I see it has swapped places with tl repo. Is this just a prep. for merge from tl -> lambda? Regards, Peter From brian.goetz at oracle.com Thu Jun 13 08:50:56 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Thu, 13 Jun 2013 11:50:56 -0400 Subject: forEach/forEachOrdered/forEachRemaining ... iterate? In-Reply-To: <51B9DB88.5000107@gmail.com> References: <51B9DB88.5000107@gmail.com> Message-ID: <51B9EA60.6040608@oracle.com> It's a mess for sure, but I am not sure whether this is a good path out of the forest. There are only so many candidate names, and the "try and give every unique semantics a unique name" eventually degenerates into them all being some form of "forEach #352", where the user code is still not readable without a decoder chart. Here are some of the dimensions covered here: - data arity (Consumer vs BiConsumer) - data projection (element, map key, map value) - sequential vs parallel - whether to prefer encounter (spatial) or temporal order - more... It is impossible for a name to be readable and writable and still precisely convey all the dimensions here; forEach is fuzzy, forEachKeyParallelInEncounterOrder is precise but awful. I don't know what the difference between iterate and forEach should be; I could learn, but it will never be obvious because of the way our brains map words to concepts. Without overloading names, it is already spiraling out of control. The goal here was for "forEach" to be the natural behavior for the thing being iterated; for a sequential stream, that is a sequential encounter-order traversal and for a parallel stream, that is a parallel temporal-order traversal. Variants of forEach (like forEachOrdered) allow you to select the less natural variant. (I would rather get rid of forEachRemaining and make them "forEach" also.) On 6/13/2013 10:47 AM, Peter Levart wrote: > I know it's a little late, but let's look at current situation. There > are 5 methods in current APIs with similar names and signatures + 1 > additional with a little different signature in Map + some similarly > named methods in ConcurrentHashMap: > > interface Stream { > void forEach(Consumer action) > void forEachOrdered(Consumer action) > } > > interface Iterable { > void forEach(Consumer action) > } > > interface Iterator { > void forEachRemaining(Consumer action) > } > > interface Spliterator { > void forEachRemaining(Consumer action) > } > > interface Map { > void forEach(BiConsumer action) > } > > class ConcurrentHashMap ... { > void forEachKey(long parallelismThreshold, > Consumer action) > void forEachKey(long parallelismThreshold, > Function transformer, > Consumer action) > void forEachValue(long parallelismThreshold, > Consumer action) > void forEachValue(long parallelismThreshold, > Function transformer, > Consumer action) > } > > > I'm wondering if the following alternative would be easier to read and > reason-about in code: > > interface Stream { > void forEach(Consumer action) > void iterate(Consumer action) > } > > interface Iterable { > void iterate(Consumer action) > } > > interface Iterator { > void iterateRemaining(Consumer action) > } > > interface Spliterator { > void iterateRemaining(Consumer action) > } > > interface Map { > void iterate(BiConsumer action) > } > > class ConcurrentHashMap ... { > void forEachKey(long parallelismThreshold, > Consumer action) > void forEachKey(long parallelismThreshold, > Function transformer, > Consumer action) > void forEachValue(long parallelismThreshold, > Consumer action) > void forEachValue(long parallelismThreshold, > Function transformer, > Consumer action) > } > > > Why? I'm a little concerned about the duality of Stream.forEach() and > Iterable.forEach(). While the later is always sequential and > encounter-ordered, the former can be executed out-of order and/or > in-parallel. I think that by naming the sequential variants differently, > the reader of code need not be concerned about the type of the target > that the method is invoked upon, just the name. This enables fast > browsing of code where the eye can quickly glance over iterate()s but > slows down on each forEach()... > > How do others feel about the (re)use of forEach... names in different > APIs? Would it be more difficult to find the right method if iterate() > was used instead of forEach() for iteration? > > > Regards, Peter > > From tom.hawtin at oracle.com Thu Jun 13 10:28:51 2013 From: tom.hawtin at oracle.com (Tom Hawtin) Date: Thu, 13 Jun 2013 18:28:51 +0100 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> Message-ID: <51BA0153.8010409@oracle.com> On 12/06/2013 17:36, Paul Sandoz wrote: > "The returned comparator is serializable and does not permit null arguments when comparing objects". Being Serializable at all is odd. It brings the previously implementation-dependent name and fields into the API spec. Serialisability also allows curious behaviour. Whilst not, say, a vulnerability itself, oddities aren't generally a good idea. For an example of strangeness, NullComparator can have a sign of -Integer.MIN_VALUE. It can also have a `real` field of null which is otherwise checked for during construction, although strangely the compare method also checks whether real is null or not. Tom From brian.goetz at oracle.com Thu Jun 13 14:48:20 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Thu, 13 Jun 2013 21:48:20 +0000 Subject: hg: lambda/lambda/jdk: Fix bug in ConcurrentSkipListMap.merge, where if a thread loses a put-race, the merge function is not consulted Message-ID: <20130613214843.85798481E1@hg.openjdk.java.net> Changeset: 7181498889ad Author: briangoetz Date: 2013-06-13 17:48 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/7181498889ad Fix bug in ConcurrentSkipListMap.merge, where if a thread loses a put-race, the merge function is not consulted ! src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java From mike.duigou at oracle.com Thu Jun 13 15:43:28 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Thu, 13 Jun 2013 22:43:28 +0000 Subject: hg: lambda/lambda/jdk: Adds ConcurrentMap.replaceAll default which uses replace(k, v, function(k, v)) and retries as appropriate. Message-ID: <20130613224351.693E8481E5@hg.openjdk.java.net> Changeset: 9fb3baef8ff7 Author: mduigou Date: 2013-06-13 15:43 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/9fb3baef8ff7 Adds ConcurrentMap.replaceAll default which uses replace(k, v, function(k,v)) and retries as appropriate. Better detection of CME in Map.replaceAll as well. ! src/share/classes/java/util/Map.java ! src/share/classes/java/util/concurrent/ConcurrentMap.java From brian.goetz at oracle.com Thu Jun 13 16:20:27 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Thu, 13 Jun 2013 23:20:27 +0000 Subject: hg: lambda/lambda/jdk: Add post-transform functionality to Collector; eliminate STRICTLY_MUTATIVE collector characteristic; restructure existing set of Collectors, including various renamings; add StringJoiner.merge() method; more Collector tests Message-ID: <20130613232051.070F6481E6@hg.openjdk.java.net> Changeset: de85a85ab586 Author: briangoetz Date: 2013-06-13 19:20 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/de85a85ab586 Add post-transform functionality to Collector; eliminate STRICTLY_MUTATIVE collector characteristic; restructure existing set of Collectors, including various renamings; add StringJoiner.merge() method; more Collector tests ! src/share/classes/java/util/DoubleSummaryStatistics.java ! src/share/classes/java/util/IntSummaryStatistics.java ! src/share/classes/java/util/LongSummaryStatistics.java ! src/share/classes/java/util/Optional.java ! src/share/classes/java/util/StringJoiner.java ! src/share/classes/java/util/stream/Collector.java ! src/share/classes/java/util/stream/Collectors.java ! src/share/classes/java/util/stream/DelegatingStream.java ! src/share/classes/java/util/stream/ReduceOps.java ! src/share/classes/java/util/stream/ReferencePipeline.java ! src/share/classes/java/util/stream/Stream.java ! test/java/lang/StringBuilder/AddAllTest.java ! test/java/util/StringJoiner/BasicTest.java ! test/java/util/stream/bootlib/java/util/stream/OpTestCase.java ! test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java ! test/jdk/lambda/MethodReferenceTestInstanceMethod.java ! test/jdk/lambda/separate/TestHarness.java From john.r.rose at oracle.com Thu Jun 13 18:55:28 2013 From: john.r.rose at oracle.com (John Rose) Date: Thu, 13 Jun 2013 18:55:28 -0700 Subject: Class verifier issues with unboxing method handles In-Reply-To: <51A5E59F.9040007@oracle.com> References: <51A5543B.10506@talios.com> <51A55E5E.4020605@oracle.com> <51A5E59F.9040007@oracle.com> Message-ID: A REF_newInvokeSpecial method handle constant refers to a void-returning method named , but its bytecode behavior returns a reference to the constructed object. This may require special checks, such as with 'actualReturnType' in AbstractValidatingLambdaMetafactory.java. There is a missing check in InnerClassLambdaMetafactory.java. Here is a suggested fix (which I have not tested). ? John diff --git a/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java b/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java --- a/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java +++ b/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java @@ -112,7 +112,10 @@ implMethodDesc = implMethodType.toMethodDescriptorString(); Type implMethodAsmType = Type.getMethodType(implMethodDesc); implMethodArgumentTypes = implMethodAsmType.getArgumentTypes(); - implMethodReturnType = implMethodAsmType.getReturnType(); + if (implKind == MethodHandleInfo.REF_newInvokeSpecial) + implMethodReturnType = Type.getType(implMethodClassName); + else + implMethodReturnType = implMethodAsmType.getReturnType(); constructorType = invokedType.changeReturnType(Void.TYPE); constructorDesc = constructorType.toMethodDescriptorString(); lambdaClassName = targetClass.getName().replace('.', '/') + "$$Lambda$" + counter.incrementAndGet(); On May 29, 2013, at 4:25 AM, Maurizio Cimadamore wrote: > David, Mark, > a minimal test case to reproduce the issue is this: > > interface IntFunction { > int m(X x); > } > > class Test { > public static void main(String[] args) { > IntFunction s = Integer::new; > } > } > > > Looking at the javap output, in particular at the indy call details, we > find this: > > BootstrapMethods: > 0: #15 invokestatic > java/lang/invoke/LambdaMetafactory.metaFactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite; > Method arguments: > #16 invokeinterface IntFunction.m:(Ljava/lang/Object;)I > #17 newinvokespecial > java/lang/Integer."":(Ljava/lang/String;)V > #18 (Ljava/lang/String;)I > > > This seems correct; however, judging from the runtime error, it seems > like the metafactory is not unboxing the Integer instance back to int > (which is the expected return value of the implemented method). Hence > the 292 link failure. Robert, Brian can you confirm? > > Maurizio > > > On 29/05/13 02:48, David Holmes wrote: >> Hi Mark, >> >> cc'ing lambda-dev. This may be a bug, a version mismatch, or something >> else. The lambda-dev folk will know. >> >> David >> >> On 29/05/2013 11:04 AM, Mark Derricutt wrote: >>> Hi all, >>> >>> Mark Reinhold suggested I posted this question/bug report to hotspot-dev >>> rather than jdk8-dev so here goes. >>> >>> I have a fairly simple test case using the new streams API: >>> >>> public static void main(String[] args) { >>> List strings = Arrays.asList("1", "2", "3", "4", "5"); >>> strings.stream() >>> .mapToInt(s -> new Integer(s)) >>> .forEach(i -> System.out.println(String.format("int %d", i))); >>> } >>> >>> >>> which compiles, runs, and prints out what I expect: >>> >>> int 1 >>> int 2 >>> int 3 >>> int 4 >>> int 5 >>> >>> >>> Given that mapToInt() is returning an IntegerStream wrapping primitive >>> ints, the result of my closure is successfully autoboxed down to an int >>> and all is happy with the world. >>> >>> If I change this code to be: >>> >>> strings.stream() >>> .mapToInt(Integer::parseInt) >>> .forEach(i -> System.out.println(String.format("int %d", i))); >>> >>> Again, everything works as expected as Integer::parseInt returns an int, >>> so there's no boxing. >>> >>> Changing this once again to: >>> >>> strings.stream() >>> .mapToInt(Integer::valueOf) >>> .forEach(i -> System.out.println(String.format("int %d", i))); >>> >>> I also see the expected result, Integer::valueOf returns an Integer >>> which is then being boxed down to an int. >>> >>> However, if I change the code to: >>> >>> strings.stream() >>> .mapToInt(Integer::new) >>> .forEach(i -> System.out.println(String.format("int %d", i))); >>> >>> which, if I understand correctly - Integer::new should be returning a >>> method handle to the constructor. IntelliJ IDEA 13 autocompletes this >>> for me, and hyperlinks to the Integer(String s) constructor, javac >>> successfully compiles the code so my -assumption- is that the >>> constructor would be called, returning an Integer which is then boxed >>> down to an int, however, this is what I get: >>> >>> Exception in thread "main" java.lang.BootstrapMethodError: call site >>> initialization exception >>> at java.lang.invoke.CallSite.makeSite(CallSite.java:298) >>> at >>> java.lang.invoke.MethodHandleNatives.linkCallSite(MethodHandleNatives.java:294) >>> >>> at com.talios.test.TestJdk.main(TestJdk.java:12) >>> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >>> at >>> sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >>> >>> at >>> sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >>> >>> at java.lang.reflect.Method.invoke(Method.java:491) >>> at >>> com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) >>> Caused by: java.lang.VerifyError: Bad type on operand stack >>> Exception Details: >>> Location: >>> com/talios/test/TestJdk$$Lambda$1.applyAsInt(Ljava/lang/Object;)I >>> @11: ireturn >>> Reason: >>> Type 'java/lang/Integer' (current frame, stack[0]) is not >>> assignable to integer >>> Current Frame: >>> bci: @11 >>> flags: { } >>> locals: { 'com/talios/test/TestJdk$$Lambda$1', 'java/lang/Object' } >>> stack: { 'java/lang/Integer' } >>> Bytecode: >>> 0000000: bb00 0e59 2bc0 0010 b700 13ac >>> >>> at java.lang.Class.getDeclaredConstructors0(Native Method) >>> at java.lang.Class.privateGetDeclaredConstructors(Class.java:2536) >>> at java.lang.Class.getDeclaredConstructors(Class.java:1928) >>> at >>> java.lang.invoke.InnerClassLambdaMetafactory$1.run(InnerClassLambdaMetafactory.java:147) >>> >>> at >>> java.lang.invoke.InnerClassLambdaMetafactory$1.run(InnerClassLambdaMetafactory.java:144) >>> >>> at java.security.AccessController.doPrivileged(Native Method) >>> at >>> java.lang.invoke.InnerClassLambdaMetafactory.buildCallSite(InnerClassLambdaMetafactory.java:143) >>> >>> at >>> java.lang.invoke.LambdaMetafactory.metaFactory(LambdaMetafactory.java:191) >>> at java.lang.invoke.CallSite.makeSite(CallSite.java:283) >>> ... 7 more >>> >>> This is on OSX Mountain Lion, with JDK 8 Build 91. >>> >>> Have I walked in an obscure corner case of method handle breakage and >>> found something new, or is this a new problem? >>> >>> Cheers, >>> Mark >>> > > From paul.sandoz at oracle.com Fri Jun 14 03:07:54 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Fri, 14 Jun 2013 12:07:54 +0200 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51BA0153.8010409@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> Message-ID: <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> On Jun 13, 2013, at 7:28 PM, Tom Hawtin wrote: > On 12/06/2013 17:36, Paul Sandoz wrote: > >> "The returned comparator is serializable and does not permit null arguments when comparing objects". > > Being Serializable at all is odd. It brings the previously > implementation-dependent name and fields into the API spec. > That is, alas, inherently the nature of serialization. Collections are serializable, some collections take Comparator instances on construction (e.g. TreeSet). > Serialisability also allows curious behaviour. Whilst not, say, a > vulnerability itself, oddities aren't generally a good idea. For an > example of strangeness, NullComparator can have a sign of > -Integer.MIN_VALUE. It can also have a `real` field of null which is > otherwise checked for during construction, I dunno what to say except "serialization is bad! i wish it were never in the JDK" :-) > although strangely the > compare method also checks whether real is null or not. > Yes, Henry is gonna fix that null check. FWIW i find this marginally clearer: NullComparator(boolean nullsFirst, Comparator real) { this(nullsFirst ? -1 : 1, real); } private NullComparator(int sign, Comparator real) { this.sign = sign; this.real = (Comparator) Objects.requireNonNull(real); } but it's just nit-picking. Paul. From boaznahum at gmail.com Fri Jun 14 03:18:19 2013 From: boaznahum at gmail.com (Boaz Nahum) Date: Fri, 14 Jun 2013 13:18:19 +0300 Subject: collect signature Message-ID: Hi Brian. I guess you already have been asked this trillion times, but, why appears in collect signature ? * R collect(Collector collector);* I tried to compile many examples(from Collectors) with: * R collect(Collector collector);* and it just compiled fine. Thanks Boaz On Fri, Jun 14, 2013 at 2:20 AM, wrote: > Changeset: de85a85ab586 > Author: briangoetz > Date: 2013-06-13 19:20 -0400 > URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/de85a85ab586 > > Add post-transform functionality to Collector; eliminate STRICTLY_MUTATIVE > collector characteristic; restructure existing set of Collectors, including > various renamings; add StringJoiner.merge() method; more Collector tests > > ! src/share/classes/java/util/DoubleSummaryStatistics.java > ! src/share/classes/java/util/IntSummaryStatistics.java > ! src/share/classes/java/util/LongSummaryStatistics.java > ! src/share/classes/java/util/Optional.java > ! src/share/classes/java/util/StringJoiner.java > ! src/share/classes/java/util/stream/Collector.java > ! src/share/classes/java/util/stream/Collectors.java > ! src/share/classes/java/util/stream/DelegatingStream.java > ! src/share/classes/java/util/stream/ReduceOps.java > ! src/share/classes/java/util/stream/ReferencePipeline.java > ! src/share/classes/java/util/stream/Stream.java > ! test/java/lang/StringBuilder/AddAllTest.java > ! test/java/util/StringJoiner/BasicTest.java > ! test/java/util/stream/bootlib/java/util/stream/OpTestCase.java > ! > test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java > ! > test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java > ! > test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java > ! > test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java > ! test/jdk/lambda/MethodReferenceTestInstanceMethod.java > ! test/jdk/lambda/separate/TestHarness.java > > > From paul.sandoz at oracle.com Fri Jun 14 03:18:01 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Fri, 14 Jun 2013 10:18:01 +0000 Subject: hg: lambda/lambda/jdk: Add bug number Message-ID: <20130614101824.C3A53481F9@hg.openjdk.java.net> Changeset: 8204c5cef60c Author: psandoz Date: 2013-06-14 11:51 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8204c5cef60c Add bug number ! test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java From forax at univ-mlv.fr Fri Jun 14 03:29:59 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Fri, 14 Jun 2013 12:29:59 +0200 Subject: collect signature In-Reply-To: References: Message-ID: <51BAF0A7.4010002@univ-mlv.fr> On 06/14/2013 12:18 PM, Boaz Nahum wrote: > Hi Brian. > > I guess you already have been asked this trillion times, but, > why appears in collect signature ? > > * R collect(Collector collector);* > > I tried to compile many examples(from Collectors) with: > > * R collect(Collector collector);* > > and it just compiled fine. > > Thanks > Boaz Good question, Collect signature was changed recently, to add a new type parameter (the I) and we are still discussing about using wildcards, or other design tricks to hide this ugly I. cheers, R?mi > > > > On Fri, Jun 14, 2013 at 2:20 AM, wrote: > >> Changeset: de85a85ab586 >> Author: briangoetz >> Date: 2013-06-13 19:20 -0400 >> URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/de85a85ab586 >> >> Add post-transform functionality to Collector; eliminate STRICTLY_MUTATIVE >> collector characteristic; restructure existing set of Collectors, including >> various renamings; add StringJoiner.merge() method; more Collector tests >> >> ! src/share/classes/java/util/DoubleSummaryStatistics.java >> ! src/share/classes/java/util/IntSummaryStatistics.java >> ! src/share/classes/java/util/LongSummaryStatistics.java >> ! src/share/classes/java/util/Optional.java >> ! src/share/classes/java/util/StringJoiner.java >> ! src/share/classes/java/util/stream/Collector.java >> ! src/share/classes/java/util/stream/Collectors.java >> ! src/share/classes/java/util/stream/DelegatingStream.java >> ! src/share/classes/java/util/stream/ReduceOps.java >> ! src/share/classes/java/util/stream/ReferencePipeline.java >> ! src/share/classes/java/util/stream/Stream.java >> ! test/java/lang/StringBuilder/AddAllTest.java >> ! test/java/util/StringJoiner/BasicTest.java >> ! test/java/util/stream/bootlib/java/util/stream/OpTestCase.java >> ! >> test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java >> ! >> test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java >> ! >> test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java >> ! >> test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java >> ! test/jdk/lambda/MethodReferenceTestInstanceMethod.java >> ! test/jdk/lambda/separate/TestHarness.java >> >> >> From forax at univ-mlv.fr Fri Jun 14 03:37:29 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Fri, 14 Jun 2013 12:37:29 +0200 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> Message-ID: <51BAF269.4000302@univ-mlv.fr> On 06/14/2013 12:07 PM, Paul Sandoz wrote: > On Jun 13, 2013, at 7:28 PM, Tom Hawtin wrote: > >> On 12/06/2013 17:36, Paul Sandoz wrote: >> >>> "The returned comparator is serializable and does not permit null arguments when comparing objects". >> Being Serializable at all is odd. It brings the previously >> implementation-dependent name and fields into the API spec. >> > That is, alas, inherently the nature of serialization. Collections are serializable, some collections take Comparator instances on construction (e.g. TreeSet). > > >> Serialisability also allows curious behaviour. Whilst not, say, a >> vulnerability itself, oddities aren't generally a good idea. For an >> example of strangeness, NullComparator can have a sign of >> -Integer.MIN_VALUE. It can also have a `real` field of null which is >> otherwise checked for during construction, > I dunno what to say except "serialization is bad! i wish it were never in the JDK" :-) > > >> although strangely the >> compare method also checks whether real is null or not. >> > Yes, Henry is gonna fix that null check. > > FWIW i find this marginally clearer: > > NullComparator(boolean nullsFirst, Comparator real) { > this(nullsFirst ? -1 : 1, real); > } > > private NullComparator(int sign, Comparator real) { > this.sign = sign; > this.real = (Comparator) Objects.requireNonNull(real); > } > > but it's just nit-picking. and why the NullComparator is specified as a class an not as a serializable lambda (and please casting a Comparator to a Comparator is unsafe, real should be declared as a Comparator). > > Paul. > > R?mi From paul.sandoz at oracle.com Fri Jun 14 03:58:42 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Fri, 14 Jun 2013 12:58:42 +0200 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51BAF269.4000302@univ-mlv.fr> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BAF269.4000302@univ-mlv.fr> Message-ID: <2F8322FF-654A-48E0-BD96-0E9BFC3D9B0D@oracle.com> On Jun 14, 2013, at 12:37 PM, Remi Forax wrote: >> FWIW i find this marginally clearer: >> >> NullComparator(boolean nullsFirst, Comparator real) { >> this(nullsFirst ? -1 : 1, real); >> } >> >> private NullComparator(int sign, Comparator real) { >> this.sign = sign; >> this.real = (Comparator) Objects.requireNonNull(real); >> } >> >> but it's just nit-picking. > > and why the NullComparator is specified as a class an not as a > serializable lambda It also overrides some default methods of Comparator. Paul. From paul.sandoz at oracle.com Fri Jun 14 04:19:22 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Fri, 14 Jun 2013 13:19:22 +0200 Subject: What happened to ConcurrentHashMap? In-Reply-To: <51B9DF9B.30004@gmail.com> References: <20130605224445.29D3548FD0@hg.openjdk.java.net> <51B9D23E.8050803@gmail.com> <51B9DF9B.30004@gmail.com> Message-ID: Hi Peter, I am not quire sure of the context of this merge, but the 166 stuff will go to tl first then get merged in with lambda. Hopefully over the next few weeks the diffs from lambda to tl will tend towards zero. Making progress with a few tl patches in review. Paul. On Jun 13, 2013, at 5:04 PM, Peter Levart wrote: > On 06/13/2013 04:07 PM, Peter Levart wrote: >> On 06/06/2013 12:21 AM, mike.duigou at oracle.com wrote: >>> Changeset: 251c9524952b >>> Author: mduigou >>> Date: 2013-06-05 13:28 -0700 >>> URL:http://hg.openjdk.java.net/lambda/lambda/jdk/rev/251c9524952b >>> >>> Merge >>> >>> ! .hgtags >>> - .jcheck/conf >>> ! src/share/classes/java/lang/String.java >>> ! src/share/classes/java/lang/StringBuffer.java >>> ! src/share/classes/java/nio/file/FileTreeIterator.java >>> ! src/share/classes/java/nio/file/Files.java >>> ! src/share/classes/java/util/Arrays.java >>> ! src/share/classes/java/util/ArraysParallelSortHelpers.java >>> ! src/share/classes/java/util/ComparableTimSort.java >>> ! src/share/classes/java/util/DualPivotQuicksort.java >>> ! src/share/classes/java/util/Spliterator.java >>> ! src/share/classes/java/util/TimSort.java >>> ! src/share/classes/java/util/concurrent/ConcurrentHashMap.java >> >> ...Are Segments back? Where are all the goodies? >> >> Regards, Peter >> > > I see it has swapped places with tl repo. Is this just a prep. for merge > from tl -> lambda? > > Regards, Peter > > From boaznahum at gmail.com Fri Jun 14 05:29:40 2013 From: boaznahum at gmail.com (Boaz Nahum) Date: Fri, 14 Jun 2013 15:29:40 +0300 Subject: collect signature In-Reply-To: <51BAF0A7.4010002@univ-mlv.fr> References: <51BAF0A7.4010002@univ-mlv.fr> Message-ID: What about: interface Collector { ActualCollector getActual(); } /** was Collector */ interface ActualCollector extends Collector { @Final @Override default ActualCollector getActual() { return this; } } Thanks Boaz On Fri, Jun 14, 2013 at 1:29 PM, Remi Forax wrote: > On 06/14/2013 12:18 PM, Boaz Nahum wrote: > > Hi Brian. > > > > I guess you already have been asked this trillion times, but, > > why appears in collect signature ? > > > > * R collect(Collector collector);* > > > > I tried to compile many examples(from Collectors) with: > > > > * R collect(Collector collector);* > > > > and it just compiled fine. > > > > Thanks > > Boaz > > Good question, > Collect signature was changed recently, to add a new type parameter (the > I) and > we are still discussing about using wildcards, or other design tricks to > hide this ugly I. > > cheers, > R?mi > > > > > > > > > On Fri, Jun 14, 2013 at 2:20 AM, wrote: > > > >> Changeset: de85a85ab586 > >> Author: briangoetz > >> Date: 2013-06-13 19:20 -0400 > >> URL: > http://hg.openjdk.java.net/lambda/lambda/jdk/rev/de85a85ab586 > >> > >> Add post-transform functionality to Collector; eliminate > STRICTLY_MUTATIVE > >> collector characteristic; restructure existing set of Collectors, > including > >> various renamings; add StringJoiner.merge() method; more Collector tests > >> > >> ! src/share/classes/java/util/DoubleSummaryStatistics.java > >> ! src/share/classes/java/util/IntSummaryStatistics.java > >> ! src/share/classes/java/util/LongSummaryStatistics.java > >> ! src/share/classes/java/util/Optional.java > >> ! src/share/classes/java/util/StringJoiner.java > >> ! src/share/classes/java/util/stream/Collector.java > >> ! src/share/classes/java/util/stream/Collectors.java > >> ! src/share/classes/java/util/stream/DelegatingStream.java > >> ! src/share/classes/java/util/stream/ReduceOps.java > >> ! src/share/classes/java/util/stream/ReferencePipeline.java > >> ! src/share/classes/java/util/stream/Stream.java > >> ! test/java/lang/StringBuilder/AddAllTest.java > >> ! test/java/util/StringJoiner/BasicTest.java > >> ! test/java/util/stream/bootlib/java/util/stream/OpTestCase.java > >> ! > >> > test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java > >> ! > >> > test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java > >> ! > >> > test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java > >> ! > >> > test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java > >> ! test/jdk/lambda/MethodReferenceTestInstanceMethod.java > >> ! test/jdk/lambda/separate/TestHarness.java > >> > >> > >> > > > From forax at univ-mlv.fr Fri Jun 14 05:29:37 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Fri, 14 Jun 2013 14:29:37 +0200 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <2F8322FF-654A-48E0-BD96-0E9BFC3D9B0D@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BAF269.4000302@univ-mlv.fr> <2F8322FF-654A-48E0-BD96-0E9BFC3D9B0D@oracle.com> Message-ID: <51BB0CB1.6000007@univ-mlv.fr> On 06/14/2013 12:58 PM, Paul Sandoz wrote: > On Jun 14, 2013, at 12:37 PM, Remi Forax wrote: >>> FWIW i find this marginally clearer: >>> >>> NullComparator(boolean nullsFirst, Comparator real) { >>> this(nullsFirst ? -1 : 1, real); >>> } >>> >>> private NullComparator(int sign, Comparator real) { >>> this.sign = sign; >>> this.real = (Comparator) Objects.requireNonNull(real); >>> } >>> >>> but it's just nit-picking. >> and why the NullComparator is specified as a class an not as a >> serializable lambda > It also overrides some default methods of Comparator. Ok, I see, Looking at the webrev, I haven't seen them in this ocean of red. > > Paul. > R?mi From tristan.yan at oracle.com Fri Jun 14 09:33:28 2013 From: tristan.yan at oracle.com (Tristan Yan) Date: Fri, 14 Jun 2013 09:33:28 -0700 (PDT) Subject: forEachOrdered's semantic Message-ID: <43e56965-b2de-4865-bfde-a7e39b41f481@default> >From other thread and spec Stream.forEachOrdered() should behave like an order iteration but latest code shows it is not sorted. Below code shows result as 10 9 3 2 7 4 6 1 5 8 This is the same output as forEach, is there anything wrong? List oneToTen = IntStream.range(1, 11).boxed() .collect(Collectors.toList()); Collections.shuffle(oneToTen); oneToTen.stream().forEachOrdered(t -> { System.out.print(t); System.out.print(" "); }); Tristan Yan(Haibo Yan) Office : 8610-61066212 Fax : 8610-61065441 Cell : 86-18610696822 2F, Building No. 24, Zhongguancun Software Park Haidian District HYPERLINK "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6:P6_CITY:Beijing"Beijing , 100193 oracle From henry.jen at oracle.com Fri Jun 14 09:44:33 2013 From: henry.jen at oracle.com (Henry Jen) Date: Fri, 14 Jun 2013 09:44:33 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> Message-ID: <51BB4871.4090007@oracle.com> On 06/14/2013 03:07 AM, Paul Sandoz wrote: > > On Jun 13, 2013, at 7:28 PM, Tom Hawtin wrote: > >> On 12/06/2013 17:36, Paul Sandoz wrote: >> >>> "The returned comparator is serializable and does not permit null arguments when comparing objects". >> >> Being Serializable at all is odd. It brings the previously >> implementation-dependent name and fields into the API spec. >> > > That is, alas, inherently the nature of serialization. Collections are serializable, some collections take Comparator instances on construction (e.g. TreeSet). > > >> Serialisability also allows curious behaviour. Whilst not, say, a >> vulnerability itself, oddities aren't generally a good idea. For an >> example of strangeness, NullComparator can have a sign of >> -Integer.MIN_VALUE. It can also have a `real` field of null which is >> otherwise checked for during construction, > > I dunno what to say except "serialization is bad! i wish it were never in the JDK" :-) > > >> although strangely the >> compare method also checks whether real is null or not. >> > > Yes, Henry is gonna fix that null check. > > FWIW i find this marginally clearer: > > NullComparator(boolean nullsFirst, Comparator real) { > this(nullsFirst ? -1 : 1, real); > } > > private NullComparator(int sign, Comparator real) { > this.sign = sign; > this.real = (Comparator) Objects.requireNonNull(real); > } > I was thinking to change sign to null to work out the -Integer.MIN_VALUE issue from serialization tampering. As null real, that's NPE at runtime, not a security threat, so I'll probably let it pass without validating at de-serialization time. Unless we feel it's important enough to fail-fast. Cheers, Henry From jason_mehrens at hotmail.com Fri Jun 14 10:10:14 2013 From: jason_mehrens at hotmail.com (Jason Mehrens) Date: Fri, 14 Jun 2013 12:10:14 -0500 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51B790E6.6020209@oracle.com> References: <51B790E6.6020209@oracle.com> Message-ID: Any chance the static method Comparator.reverseOrder() will be renamed to something like reversedNaturalOrder? Now all of the calls to Comparator.reverseOrder() take on new meaning. Jason > Date: Tue, 11 Jun 2013 14:04:38 -0700 > From: henry.jen at oracle.com > To: lambda-dev at openjdk.java.net; core-libs-dev at openjdk.java.net > Subject: RFR 8009736: Comparator API cleanup > > Hi, > > Please review http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/webrev/ > > Highlight of changes, > > - Comparators class is now only package-private implementations. The > public static methods have been move to other arguably more appropriate > places, mostly in Comparator. > > - Comparator.reverseOrder() is renamed to Comparator.reversed() > > - nullsFirst(Comparator) and nullsLast(Comparator) are introduced to > wrap up a comparator to be null-friendly. > > To see the API changes, found the specdiff at > http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/specdiff/overview-summary.html > > Cheers, > Henry From brian.goetz at oracle.com Fri Jun 14 11:13:42 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Fri, 14 Jun 2013 14:13:42 -0400 Subject: forEachOrdered's semantic In-Reply-To: <43e56965-b2de-4865-bfde-a7e39b41f481@default> References: <43e56965-b2de-4865-bfde-a7e39b41f481@default> Message-ID: <51BB5D56.6020309@oracle.com> There is a difference between *ordered* and *sorted*. Ordered means "has a defined encounter order". Indexed aggregates (Lists, arrays), queues, and sorted collections all have a defined encounter order; hash-based collections (e.g., HashSet) do not. Sorted implies ordered, but it further implies a specific order. Whether a stream is ordered or not is important, because there are optimizations that are legal only for unordered streams, which are relevant for parallel executions. This is why there are two versions of forEach. The normal version of forEach is not constrained to the encounter order, but instead delivers elements to the consumer as they are ready. (This is sometimes called the *temporal order*.) Most of the time this is what people want when they do forEach on a parallel stream. But if they really want the elements in their encounter order, you can use forEachOrdered. This is likely identical to forEach for sequential traversals, but likely slower than forEach for parallel traversals. However, you still may be able to get some parallelism benefit anyway, such as in cases like stream.parallel() .filter(veryExpensiveFn) .forEachOrdered(...) This at least lets the expensive operation be parallelized, and then the elements are delivered in left-to-right order. (If the stream source is unordered then this degenerates to the same as the regular unordered forEach.) On 6/14/2013 12:33 PM, Tristan Yan wrote: >>From other thread and spec Stream.forEachOrdered() should behave like an order iteration but latest code shows it is not sorted. Below code shows result as > > 10 9 3 2 7 4 6 1 5 8 > > This is the same output as forEach, is there anything wrong? > > List oneToTen = IntStream.range(1, 11).boxed() > > .collect(Collectors.toList()); > > Collections.shuffle(oneToTen); > > oneToTen.stream().forEachOrdered(t -> { > > System.out.print(t); > > System.out.print(" "); > > }); > > > > Tristan Yan(Haibo Yan) > > Office : 8610-61066212 > > Fax : 8610-61065441 > > Cell : 86-18610696822 > > > > 2F, Building No. 24, Zhongguancun Software Park > > Haidian District HYPERLINK "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6:P6_CITY:Beijing"Beijing , 100193 > > oracle > > > > > > From jgetino at telefonica.net Fri Jun 14 12:41:28 2013 From: jgetino at telefonica.net (Jose) Date: Fri, 14 Jun 2013 21:41:28 +0200 Subject: Primitive specializations Message-ID: <66BC2B5469AB487485D72FA43C7A7828@Microx32> In the spirit of the primitive specializations of Iterator I wonder if it would be possible to make LongConsumer being a specialization of Consumer. On the other hand I would like to know if it can be expected that in future releases the compiler will be able to disambiguate between foo(LongConsumer c) and foo(Cosumer.c) when a lambda is passed as argument. Thanks . From pbenedict at apache.org Fri Jun 14 12:51:23 2013 From: pbenedict at apache.org (Paul Benedict) Date: Fri, 14 Jun 2013 14:51:23 -0500 Subject: Primitive specializations In-Reply-To: <66BC2B5469AB487485D72FA43C7A7828@Microx32> References: <66BC2B5469AB487485D72FA43C7A7828@Microx32> Message-ID: I believe the problem with that kind of specialization is that it makes Java box the primitive types. The current scheme avoids that performance penalty. On Fri, Jun 14, 2013 at 2:41 PM, Jose wrote: > In the spirit of the primitive specializations of Iterator I wonder if it > would be possible to make LongConsumer being a specialization of > Consumer. > > > > On the other hand I would like to know if it can be expected that in future > releases the compiler will be able to disambiguate between > > > > foo(LongConsumer c) and foo(Cosumer.c) > > > > when a lambda is passed as argument. > > > > Thanks > > > > > > > > . > > > > > > > From brian.goetz at oracle.com Fri Jun 14 12:59:50 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Fri, 14 Jun 2013 15:59:50 -0400 Subject: Primitive specializations In-Reply-To: References: <66BC2B5469AB487485D72FA43C7A7828@Microx32> Message-ID: <51BB7636.6040406@oracle.com> We tried this already. Indeed, we ran into issues with ambiguities of the sort you describe. On 6/14/2013 3:51 PM, Paul Benedict wrote: > I believe the problem with that kind of specialization is that it makes > Java box the primitive types. The current scheme avoids that performance > penalty. > > > On Fri, Jun 14, 2013 at 2:41 PM, Jose wrote: > >> In the spirit of the primitive specializations of Iterator I wonder if it >> would be possible to make LongConsumer being a specialization of >> Consumer. >> >> >> >> On the other hand I would like to know if it can be expected that in future >> releases the compiler will be able to disambiguate between >> >> >> >> foo(LongConsumer c) and foo(Cosumer.c) >> >> >> >> when a lambda is passed as argument. >> >> >> >> Thanks >> >> >> >> >> >> >> >> . >> >> >> >> >> >> >> > From brian.goetz at oracle.com Fri Jun 14 12:49:34 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Fri, 14 Jun 2013 19:49:34 +0000 Subject: hg: lambda/lambda/jdk: Update javadoc on Collection, Collections Message-ID: <20130614195009.5678F48216@hg.openjdk.java.net> Changeset: 228f7d406f50 Author: briangoetz Date: 2013-06-14 15:49 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/228f7d406f50 Update javadoc on Collection, Collections ! src/share/classes/java/util/stream/Collector.java ! src/share/classes/java/util/stream/Collectors.java From brian.goetz at oracle.com Fri Jun 14 13:21:30 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Fri, 14 Jun 2013 16:21:30 -0400 Subject: collect signature In-Reply-To: References: Message-ID: <51BB7B4A.20304@oracle.com> So, the implementation of collect() actually cares about what I is; therefore it makes sense for I to show up in the signature. The intermediate type I (later renamed to A in Collector, but this hasn't propagated to Stream yet) in Collector is relevant to those implementing a Collector (like the implementations in Collectors), or implementing a reduction using Collector (like Stream.collect()), but most *users* of collect()-like facilities will not care about the specific intermediate accumulation type. (In some cases, they just don't care (e.g., toList()), whereas in other cases, it actually should be hidden from them (e.g., that joining() uses StringBuilder and not StringBuffer). Methods that return a Collector can, but are not obligated to, indicate they are hiding this intermediate type by specifying ? for A in the type instantiation of Collector, as in: Collector, which means "Collector from CharSequence to String using an unknown intermediate type". This is what we've done for all the methods in Collectors.) There have been many workarounds proposed to "hide" (unfortunately only partially) the stray wildcard from the users' sensitive eyes, but so far all of these seem firmly in "cure is worse than the disease" territory. On 6/14/2013 6:18 AM, Boaz Nahum wrote: > Hi Brian. > > I guess you already have been asked this trillion times, but, > why appears in collect signature ? > > * R collect(Collector collector);* > > I tried to compile many examples(from Collectors) with: > > * R collect(Collector collector);* > > and it just compiled fine. > > Thanks > Boaz > > > > On Fri, Jun 14, 2013 at 2:20 AM, wrote: > >> Changeset: de85a85ab586 >> Author: briangoetz >> Date: 2013-06-13 19:20 -0400 >> URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/de85a85ab586 >> >> Add post-transform functionality to Collector; eliminate STRICTLY_MUTATIVE >> collector characteristic; restructure existing set of Collectors, including >> various renamings; add StringJoiner.merge() method; more Collector tests >> >> ! src/share/classes/java/util/DoubleSummaryStatistics.java >> ! src/share/classes/java/util/IntSummaryStatistics.java >> ! src/share/classes/java/util/LongSummaryStatistics.java >> ! src/share/classes/java/util/Optional.java >> ! src/share/classes/java/util/StringJoiner.java >> ! src/share/classes/java/util/stream/Collector.java >> ! src/share/classes/java/util/stream/Collectors.java >> ! src/share/classes/java/util/stream/DelegatingStream.java >> ! src/share/classes/java/util/stream/ReduceOps.java >> ! src/share/classes/java/util/stream/ReferencePipeline.java >> ! src/share/classes/java/util/stream/Stream.java >> ! test/java/lang/StringBuilder/AddAllTest.java >> ! test/java/util/StringJoiner/BasicTest.java >> ! test/java/util/stream/bootlib/java/util/stream/OpTestCase.java >> ! >> test/java/util/stream/test/org/openjdk/tests/java/util/FillableStringTest.java >> ! >> test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java >> ! >> test/java/util/stream/test/org/openjdk/tests/java/util/stream/SummaryStatisticsTest.java >> ! >> test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java >> ! test/jdk/lambda/MethodReferenceTestInstanceMethod.java >> ! test/jdk/lambda/separate/TestHarness.java >> >> >> > From tom.hawtin at oracle.com Fri Jun 14 14:26:57 2013 From: tom.hawtin at oracle.com (Tom Hawtin) Date: Fri, 14 Jun 2013 22:26:57 +0100 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> Message-ID: <51BB8AA1.3080208@oracle.com> On 14/06/2013 11:07, Paul Sandoz wrote: > > On Jun 13, 2013, at 7:28 PM, Tom Hawtin wrote: > >> On 12/06/2013 17:36, Paul Sandoz wrote: >> >>> "The returned comparator is serializable and does not permit null arguments when comparing objects". >> >> Being Serializable at all is odd. It brings the previously >> implementation-dependent name and fields into the API spec. >> > > That is, alas, inherently the nature of serialization. Collections are serializable, some collections take Comparator instances on construction (e.g. TreeSet). It follows that reasonably some Comparators should be Serializable, but it does not follow that all Comparators are necessarily Serializable. You can have, say, a TreeSet but it isn't necessarily [runtime] serialisable. As is Comparators$NullComparator will appear in the spec for all time. I want to check that we're happy with this. > I dunno what to say except "serialization is bad! i wish it were never in the JDK" :-) And the same for most of the rest of the Java Class Library*. Tom *There are parts of String which I think are okay. From john.r.rose at oracle.com Fri Jun 14 14:44:36 2013 From: john.r.rose at oracle.com (John Rose) Date: Fri, 14 Jun 2013 14:44:36 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> Message-ID: <0FC8EA49-3042-4AD3-A80C-265416814765@oracle.com> On Jun 14, 2013, at 3:07 AM, Paul Sandoz wrote: > this.real = (Comparator) Objects.requireNonNull(real); Regarding this idiom, I added the following comment to JDK-6919064: > New JDK 8 code is making frequent use of static methods like Objects.requireNonNull and Objects.equal. If these were open-coded (that is, inlined by hand), the branches and virtual calls (to Object.equals) would be profiled per caller. As global functions, their profiles are polluted, which may cause performance problems. > > A fix to this bug should demonstrate that Objects.requireNonNull and Objects.equal are as fast as their open-coded equivalents, even in the presence of profile pollution. To pollute the profile of these methods, simply pre-warm the benchmark by a small loop passing a variety of nulls and non-null references to various classes to the arguments of these methods. http://bugs.sun.com/view_bug.do?bug_id=6919064 ? John From john.r.rose at oracle.com Fri Jun 14 16:02:59 2013 From: john.r.rose at oracle.com (John Rose) Date: Fri, 14 Jun 2013 16:02:59 -0700 Subject: collect signature In-Reply-To: <51BB7B4A.20304@oracle.com> References: <51BB7B4A.20304@oracle.com> Message-ID: <19EAD346-9EAB-4E91-A431-86DD004AD178@oracle.com> On Jun 14, 2013, at 1:21 PM, Brian Goetz wrote: > "cure is worse than the disease" Since it's Friday, I humbly offer this snake oil: A Collection is a kitchen sink, Typesafely plumbed by nerds: Its Accumulating list is ready to consist Of Reductorial words. http://www.youtube.com/watch?v=PscQSSdlX-Q ? John From john.r.rose at oracle.com Fri Jun 14 16:06:40 2013 From: john.r.rose at oracle.com (John Rose) Date: Fri, 14 Jun 2013 16:06:40 -0700 Subject: collect signature In-Reply-To: <19EAD346-9EAB-4E91-A431-86DD004AD178@oracle.com> References: <51BB7B4A.20304@oracle.com> <19EAD346-9EAB-4E91-A431-86DD004AD178@oracle.com> Message-ID: <64632E57-1D16-43F1-8737-F0CC08C59205@oracle.com> (Oops, make that "Collector ".) On Jun 14, 2013, at 4:02 PM, John Rose wrote: > On Jun 14, 2013, at 1:21 PM, Brian Goetz wrote: > >> "cure is worse than the disease" > > Since it's Friday, I humbly offer this snake oil: > > A Collection is a kitchen sink, > Typesafely plumbed by nerds: > Its Accumulating list is ready to consist > Of Reductorial words. > > http://www.youtube.com/watch?v=PscQSSdlX-Q > > ? John > From forax at univ-mlv.fr Fri Jun 14 16:12:20 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Sat, 15 Jun 2013 01:12:20 +0200 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <0FC8EA49-3042-4AD3-A80C-265416814765@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <0FC8EA49-3042-4AD3-A80C-265416814765@oracle.com> Message-ID: <51BBA354.1040403@univ-mlv.fr> On 06/14/2013 11:44 PM, John Rose wrote: > On Jun 14, 2013, at 3:07 AM, Paul Sandoz wrote: > >> this.real = (Comparator) Objects.requireNonNull(real); > Regarding this idiom, I added the following comment to JDK-6919064: > >> New JDK 8 code is making frequent use of static methods like Objects.requireNonNull and Objects.equal. If these were open-coded (that is, inlined by hand), the branches and virtual calls (to Object.equals) would be profiled per caller. As global functions, their profiles are polluted, which may cause performance problems. >> A fix to this bug should demonstrate that Objects.requireNonNull and Objects.equal are as fast as their open-coded equivalents, even in the presence of profile pollution. To pollute the profile of these methods, simply pre-warm the benchmark by a small loop passing a variety of nulls and non-null references to various classes to the arguments of these methods. > http://bugs.sun.com/view_bug.do?bug_id=6919064 > > ? John > Objects.requireNonNull is as fast as a hand written check if there is no code that catch the NullPointerException thrown by requireNonNull in the whole application. I think it's more efficient for the whole Java community to start a witch hunt to find developers that write codes that catch NPEs thrown by a Objects.requireNonNull than to write benchmarks for every methods that starts with a Objects.requireNonNull. The other solution is to fix http://bugs.sun.com/view_bug.do?bug_id=8015416 R?mi From brian.goetz at oracle.com Fri Jun 14 17:56:10 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Fri, 14 Jun 2013 20:56:10 -0400 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51BB8AA1.3080208@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BB8AA1.3080208@oracle.com> Message-ID: <51BBBBAA.3090400@oracle.com> Yeah, but once you make one not-serializable, there's no way to un-not-serializable it. (Serializable is a misnomer; really what we have is the ability to say "not serialization-hostile.") So if any ever need to be serializable, we either need to make them all so, or have two versions of each factory/combinator. Awful options all around. On 6/14/2013 5:26 PM, Tom Hawtin wrote: > On 14/06/2013 11:07, Paul Sandoz wrote: >> >> On Jun 13, 2013, at 7:28 PM, Tom Hawtin wrote: >> >>> On 12/06/2013 17:36, Paul Sandoz wrote: >>> >>>> "The returned comparator is serializable and does not permit null arguments when comparing objects". >>> >>> Being Serializable at all is odd. It brings the previously >>> implementation-dependent name and fields into the API spec. >>> >> >> That is, alas, inherently the nature of serialization. Collections are serializable, some collections take Comparator instances on construction (e.g. TreeSet). > > It follows that reasonably some Comparators should be Serializable, but > it does not follow that all Comparators are necessarily Serializable. > You can have, say, a TreeSet but it isn't necessarily > [runtime] serialisable. > > As is Comparators$NullComparator will appear in the spec for all time. I > want to check that we're happy with this. > >> I dunno what to say except "serialization is bad! i wish it were never in the JDK" :-) > > And the same for most of the rest of the Java Class Library*. > > Tom > > *There are parts of String which I think are okay. > From tristan.yan at oracle.com Fri Jun 14 21:21:31 2013 From: tristan.yan at oracle.com (Tristan Yan) Date: Fri, 14 Jun 2013 21:21:31 -0700 (PDT) Subject: =?gb2312?B?tPC4tDogZm9yRWFjaE9yZGVyZWQncyBzZW1hbnRpYw==?= In-Reply-To: <51BB5D56.6020309@oracle.com> References: <43e56965-b2de-4865-bfde-a7e39b41f481@default> <51BB5D56.6020309@oracle.com> Message-ID: <024c7271-bc8f-4155-b114-75b2e0b9db43@default> "If the stream source is unordered then this degenerates to the same as the regular unordered forEach" - Does it mean we can't guarantee same order even we do forEachOrder in stream which source is unordered? -----????----- ???: Brian Goetz ????: Saturday, June 15, 2013 2:14 AM ???: Tristan Yan ??: lambda-dev at openjdk.java.net ??: Re: forEachOrdered's semantic There is a difference between *ordered* and *sorted*. Ordered means "has a defined encounter order". Indexed aggregates (Lists, arrays), queues, and sorted collections all have a defined encounter order; hash-based collections (e.g., HashSet) do not. Sorted implies ordered, but it further implies a specific order. Whether a stream is ordered or not is important, because there are optimizations that are legal only for unordered streams, which are relevant for parallel executions. This is why there are two versions of forEach. The normal version of forEach is not constrained to the encounter order, but instead delivers elements to the consumer as they are ready. (This is sometimes called the *temporal order*.) Most of the time this is what people want when they do forEach on a parallel stream. But if they really want the elements in their encounter order, you can use forEachOrdered. This is likely identical to forEach for sequential traversals, but likely slower than forEach for parallel traversals. However, you still may be able to get some parallelism benefit anyway, such as in cases like stream.parallel() .filter(veryExpensiveFn) .forEachOrdered(...) This at least lets the expensive operation be parallelized, and then the elements are delivered in left-to-right order. (If the stream source is unordered then this degenerates to the same as the regular unordered forEach.) On 6/14/2013 12:33 PM, Tristan Yan wrote: >>From other thread and spec Stream.forEachOrdered() should behave like >>an order iteration but latest code shows it is not sorted. Below code >>shows result as > > 10 9 3 2 7 4 6 1 5 8 > > This is the same output as forEach, is there anything wrong? > > List oneToTen = IntStream.range(1, 11).boxed() > > .collect(Collectors.toList()); > > Collections.shuffle(oneToTen); > > oneToTen.stream().forEachOrdered(t -> { > > System.out.print(t); > > System.out.print(" "); > > }); > > > > Tristan Yan(Haibo Yan) > > Office : 8610-61066212 > > Fax : 8610-61065441 > > Cell : 86-18610696822 > > > > 2F, Building No. 24, Zhongguancun Software Park > > Haidian District HYPERLINK > "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6 > :P6_CITY:Beijing"Beijing , 100193 > > oracle > > > > > > From henry.jen at oracle.com Sat Jun 15 13:40:46 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Sat, 15 Jun 2013 20:40:46 +0000 Subject: hg: lambda/lambda/jdk: Review feedbacks Message-ID: <20130615204124.D083B48242@hg.openjdk.java.net> Changeset: 76d129f9bbfa Author: henryjen Date: 2013-06-15 13:39 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/76d129f9bbfa Review feedbacks ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Comparators.java ! src/share/classes/java/util/Map.java ! test/java/util/Comparator/BasicTest.java ! test/java/util/Comparator/TypeTest.java From henry.jen at oracle.com Sat Jun 15 16:27:09 2013 From: henry.jen at oracle.com (Henry Jen) Date: Sat, 15 Jun 2013 16:27:09 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: References: <51B790E6.6020209@oracle.com> Message-ID: <51BCF84D.6050408@oracle.com> On 06/14/2013 10:10 AM, Jason Mehrens wrote: > Any chance the static method Comparator.reverseOrder() will be renamed > to something like reversedNaturalOrder? Now all of the calls to > Comparator.reverseOrder() take on new meaning. > I feel that it's inconvenient for early adapters, but this is still the new API in 8 and we should still choose the best name. reverseOrder() is a natural choice and just a migration from Comparators. The old reverseOrder() is an instance default method, and is a compromise of reverse() for name clashing, I think reversed() is the right name. As the renaming of that default method is necessary, I think it's just need more attention on find out all method calls. The difference between a static and default method can be used to hint on search in files. Cheers, Henry From paul.sandoz at oracle.com Mon Jun 17 01:50:36 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Mon, 17 Jun 2013 10:50:36 +0200 Subject: forEachOrdered's semantic In-Reply-To: <024c7271-bc8f-4155-b114-75b2e0b9db43@default> References: <43e56965-b2de-4865-bfde-a7e39b41f481@default> <51BB5D56.6020309@oracle.com> <024c7271-bc8f-4155-b114-75b2e0b9db43@default> Message-ID: On Jun 15, 2013, at 6:21 AM, Tristan Yan wrote: > "If the stream source is unordered then this degenerates to the same as the regular unordered forEach" - Does it mean we can't guarantee same order even we do forEachOrder in stream which source is unordered? Correct, because there is no order in which to guarantee. It's an implementation detail that any is order is imputed. A HashSet implementation does not guarantee an order when traversing it's elements. It happens to be an implementation detail that one can impute an order when sequentially operating on an instance, but there is no future guarantees that will be the case for the same instance, or a new instance with the same content, or a new run of the same program. So while you might see the same results produced when evaluating sequentially (from an arbitrary imputed order) it's just an implementation detail. When evaluating in parallel there are various tricks we can do to reduce memory and/or increase performance if we know an input lacks order. Here is a little quiz: Set s = IntStream.range(0, 100).map(Integer::toString).collect(toSet()); Set ss = s.parallelStream().limit(10).collect(toSet()); How is the set "s" related to the set "ss" ? (Use the lambda code base to run the above.) Paul. From paul.sandoz at oracle.com Mon Jun 17 02:06:28 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Mon, 17 Jun 2013 11:06:28 +0200 Subject: Loose end: zip In-Reply-To: References: <51B0E7B1.70008@oracle.com> Message-ID: Hi Richard, Thanks for the feedback. I presume if developers are capable of understanding those topics you mention they are capable of, and as you say, most likely will implement their own zip-like abstractions, perhaps with better parallel characteristics. This seems like a no-win situation here. If we keep zip there will be demands for primitive support, "I want java.lang.Pair!", and "i want to keep on trucking processing addition elements of the longer stream with some identity or default value" i.e. zip satisfies the "tick test" but perhaps not much else. My inclination would be to field questions of why there is no zip (leading to wider the tuples discussion) and provide an example of zip (much like the current implementation). Paul. On Jun 11, 2013, at 3:59 PM, Richard Warburton wrote: > Hi, > > If anyone has experimented with Streams.zip can you provide some feedback? see email below for context. > > Thanks for asking ;) > > > Still feeling kind of YAGNI on zip, for the reasons cited in the message below, plus: > > - No primitive versions (would require new SAMs) > > - Hard to parallelize > > - Multiple ways to deal with streams of different length; we pick one > > > > Might this be something best provided by some other library than the JDK? Or as a code example somewhere people can crib from to roll their own? > > > > On 5/1/2013 5:10 PM, Brian Goetz wrote: > >> Right, but the question is, how badly can we implement it and have it > >> not be worse than nothing? And, with the current performance > >> characteristics (new object per element), are we below that threshold? > >> > >> My problem is the same as with flatMap -- these are idioms from other > >> languages that *translate poorly* to Java because of the lack of tuples > >> and other structural types. (The flatMap we got left with -- which I > >> reluctantly supported as the lesser of evils -- is, coincidentally, the > >> only other stream operation that has allocation-per-element.) At what > >> level of translation-fidelity loss do we say "yeah, it works great in > >> that other environment, but too much is lost in translation"? > >> > >> I don't doubt the utility of zip, or the fact that Joe-alikes will want > >> it, and would be bummed to not find it. My question is whether the > >> crappy zip we can have is better than no zip. (Where better doesn't > >> just mean "better than nothing", but carries its weight.) > > The things that I've come across where Streams.zip is appropriate are all fairly mathematical in nature: > > - vector dot product > - signal convolution > - cross-correlation + auto-correlation > - finite impulse response filters > - discrete-time fourier transform > > The last 4 examples are all situations in which people do generally care about the implementation's performance, rather than being willing to pay a cost in favour of abstraction. They are also situations in which you want primitives, rather than boxed numerical values. Furthermore convolution, cross-correlation of them are implementable in terms of the fourier transform and auto-correlation in terms of cross-correlation. So I guess my usage of Streams.zip suggests that a slow, boxed only, version wouldn't actually be used to implement the algorithms that its useful for. > > There's certainly user demand for it though. Before zip was added we did have several people ask about zip at lambdas hackdays. Sadly I failed to ask them why and what their motivation was. Sorry about that. Its almost inevitable that if you leave it out that people will be asking the question "why is there no zip or zipWith in Java?" until the end of time in the same way that people ask about tuples until the end of time. > > regards, > > Dr. Richard Warburton > > http://insightfullogic.com > @RichardWarburto From paul.sandoz at oracle.com Mon Jun 17 03:54:58 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Mon, 17 Jun 2013 10:54:58 +0000 Subject: hg: lambda/lambda/jdk: Fix compilation issues with some tests due to refactoring APIs. Message-ID: <20130617105520.F223A48264@hg.openjdk.java.net> Changeset: 925fa90d4e8d Author: psandoz Date: 2013-06-17 12:54 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/925fa90d4e8d Fix compilation issues with some tests due to refactoring APIs. ! test/java/lang/StringBuilder/AddAllTest.java ! test/java/nio/file/Files/StreamTest.java From paul.sandoz at oracle.com Mon Jun 17 07:35:49 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Mon, 17 Jun 2013 16:35:49 +0200 Subject: Class verifier issues with unboxing method handles In-Reply-To: References: <51A5543B.10506@talios.com> <51A55E5E.4020605@oracle.com> <51A5E59F.9040007@oracle.com> Message-ID: <880B4D08-826B-4F6F-9FEF-5DC932ABDE10@oracle.com> I tried playing around with that fix. It pushes the error further along to somewhere else. I don't know the exact terms here... but: implMethodReturnType = Type.getType(implMethodClassName) creates a type whose description is "java/lang/Integer" rather than "Ljava/lang/Integer" i.e. the input is not a type descriptor is just a class name with '.' replaced with '/'. (Perhaps that could be a bug in ASM not throwing an exception on an illegal description?) If i do the following then it works: if (implKind == MethodHandleInfo.REF_newInvokeSpecial) { implMethodReturnType = Type.getObjectType(implMethodClassName); } else { implMethodReturnType = implMethodAsmType.getReturnType(); } Plus it does not cause additional failures in the lambda lang/invoke tests (same number of tests fail before and after the fix, but i dunno if they are exactly the same tests that fail :-) ). Paul. On Jun 14, 2013, at 3:55 AM, John Rose wrote: > A REF_newInvokeSpecial method handle constant refers to a void-returning method named , but its bytecode behavior returns a reference to the constructed object. > > This may require special checks, such as with 'actualReturnType' in AbstractValidatingLambdaMetafactory.java. > > There is a missing check in InnerClassLambdaMetafactory.java. Here is a suggested fix (which I have not tested). > > ? John > > diff --git a/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java b/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java > --- a/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java > +++ b/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java > @@ -112,7 +112,10 @@ > implMethodDesc = implMethodType.toMethodDescriptorString(); > Type implMethodAsmType = Type.getMethodType(implMethodDesc); > implMethodArgumentTypes = implMethodAsmType.getArgumentTypes(); > - implMethodReturnType = implMethodAsmType.getReturnType(); > + if (implKind == MethodHandleInfo.REF_newInvokeSpecial) > + implMethodReturnType = Type.getType(implMethodClassName); > + else > + implMethodReturnType = implMethodAsmType.getReturnType(); > constructorType = invokedType.changeReturnType(Void.TYPE); > constructorDesc = constructorType.toMethodDescriptorString(); > lambdaClassName = targetClass.getName().replace('.', '/') + "$$Lambda$" + counter.incrementAndGet(); > > > On May 29, 2013, at 4:25 AM, Maurizio Cimadamore wrote: > >> David, Mark, >> a minimal test case to reproduce the issue is this: >> >> interface IntFunction { >> int m(X x); >> } >> >> class Test { >> public static void main(String[] args) { >> IntFunction s = Integer::new; >> } >> } >> >> >> Looking at the javap output, in particular at the indy call details, we >> find this: >> >> BootstrapMethods: >> 0: #15 invokestatic >> java/lang/invoke/LambdaMetafactory.metaFactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite; >> Method arguments: >> #16 invokeinterface IntFunction.m:(Ljava/lang/Object;)I >> #17 newinvokespecial >> java/lang/Integer."":(Ljava/lang/String;)V >> #18 (Ljava/lang/String;)I >> >> >> This seems correct; however, judging from the runtime error, it seems >> like the metafactory is not unboxing the Integer instance back to int >> (which is the expected return value of the implemented method). Hence >> the 292 link failure. Robert, Brian can you confirm? >> >> Maurizio >> >> >> On 29/05/13 02:48, David Holmes wrote: >>> Hi Mark, >>> >>> cc'ing lambda-dev. This may be a bug, a version mismatch, or something >>> else. The lambda-dev folk will know. >>> >>> David >>> >>> On 29/05/2013 11:04 AM, Mark Derricutt wrote: >>>> Hi all, >>>> >>>> Mark Reinhold suggested I posted this question/bug report to hotspot-dev >>>> rather than jdk8-dev so here goes. >>>> >>>> I have a fairly simple test case using the new streams API: >>>> >>>> public static void main(String[] args) { >>>> List strings = Arrays.asList("1", "2", "3", "4", "5"); >>>> strings.stream() >>>> .mapToInt(s -> new Integer(s)) >>>> .forEach(i -> System.out.println(String.format("int %d", i))); >>>> } >>>> >>>> >>>> which compiles, runs, and prints out what I expect: >>>> >>>> int 1 >>>> int 2 >>>> int 3 >>>> int 4 >>>> int 5 >>>> >>>> >>>> Given that mapToInt() is returning an IntegerStream wrapping primitive >>>> ints, the result of my closure is successfully autoboxed down to an int >>>> and all is happy with the world. >>>> >>>> If I change this code to be: >>>> >>>> strings.stream() >>>> .mapToInt(Integer::parseInt) >>>> .forEach(i -> System.out.println(String.format("int %d", i))); >>>> >>>> Again, everything works as expected as Integer::parseInt returns an int, >>>> so there's no boxing. >>>> >>>> Changing this once again to: >>>> >>>> strings.stream() >>>> .mapToInt(Integer::valueOf) >>>> .forEach(i -> System.out.println(String.format("int %d", i))); >>>> >>>> I also see the expected result, Integer::valueOf returns an Integer >>>> which is then being boxed down to an int. >>>> >>>> However, if I change the code to: >>>> >>>> strings.stream() >>>> .mapToInt(Integer::new) >>>> .forEach(i -> System.out.println(String.format("int %d", i))); >>>> >>>> which, if I understand correctly - Integer::new should be returning a >>>> method handle to the constructor. IntelliJ IDEA 13 autocompletes this >>>> for me, and hyperlinks to the Integer(String s) constructor, javac >>>> successfully compiles the code so my -assumption- is that the >>>> constructor would be called, returning an Integer which is then boxed >>>> down to an int, however, this is what I get: >>>> >>>> Exception in thread "main" java.lang.BootstrapMethodError: call site >>>> initialization exception >>>> at java.lang.invoke.CallSite.makeSite(CallSite.java:298) >>>> at >>>> java.lang.invoke.MethodHandleNatives.linkCallSite(MethodHandleNatives.java:294) >>>> >>>> at com.talios.test.TestJdk.main(TestJdk.java:12) >>>> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >>>> at >>>> sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >>>> >>>> at >>>> sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >>>> >>>> at java.lang.reflect.Method.invoke(Method.java:491) >>>> at >>>> com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) >>>> Caused by: java.lang.VerifyError: Bad type on operand stack >>>> Exception Details: >>>> Location: >>>> com/talios/test/TestJdk$$Lambda$1.applyAsInt(Ljava/lang/Object;)I >>>> @11: ireturn >>>> Reason: >>>> Type 'java/lang/Integer' (current frame, stack[0]) is not >>>> assignable to integer >>>> Current Frame: >>>> bci: @11 >>>> flags: { } >>>> locals: { 'com/talios/test/TestJdk$$Lambda$1', 'java/lang/Object' } >>>> stack: { 'java/lang/Integer' } >>>> Bytecode: >>>> 0000000: bb00 0e59 2bc0 0010 b700 13ac >>>> >>>> at java.lang.Class.getDeclaredConstructors0(Native Method) >>>> at java.lang.Class.privateGetDeclaredConstructors(Class.java:2536) >>>> at java.lang.Class.getDeclaredConstructors(Class.java:1928) >>>> at >>>> java.lang.invoke.InnerClassLambdaMetafactory$1.run(InnerClassLambdaMetafactory.java:147) >>>> >>>> at >>>> java.lang.invoke.InnerClassLambdaMetafactory$1.run(InnerClassLambdaMetafactory.java:144) >>>> >>>> at java.security.AccessController.doPrivileged(Native Method) >>>> at >>>> java.lang.invoke.InnerClassLambdaMetafactory.buildCallSite(InnerClassLambdaMetafactory.java:143) >>>> >>>> at >>>> java.lang.invoke.LambdaMetafactory.metaFactory(LambdaMetafactory.java:191) >>>> at java.lang.invoke.CallSite.makeSite(CallSite.java:283) >>>> ... 7 more >>>> >>>> This is on OSX Mountain Lion, with JDK 8 Build 91. >>>> >>>> Have I walked in an obscure corner case of method handle breakage and >>>> found something new, or is this a new problem? >>>> >>>> Cheers, >>>> Mark >>>> >> >> > > From Robert.Field at oracle.com Mon Jun 17 08:50:36 2013 From: Robert.Field at oracle.com (Robert Field) Date: Mon, 17 Jun 2013 08:50:36 -0700 Subject: Class verifier issues with unboxing method handles In-Reply-To: <880B4D08-826B-4F6F-9FEF-5DC932ABDE10@oracle.com> References: <51A5543B.10506@talios.com> <51A55E5E.4020605@oracle.com> <51A5E59F.9040007@oracle.com> <880B4D08-826B-4F6F-9FEF-5DC932ABDE10@oracle.com> Message-ID: <51BF304C.4020208@oracle.com> Thanks Mark, John, and Paul. I've created: JDK-8016761 - Lambda metafactory: incorrect type conversion of constructor method handle And assigned it to myself. -Robert On 6/17/13 7:35 AM, Paul Sandoz wrote: > I tried playing around with that fix. It pushes the error further along to somewhere else. > > I don't know the exact terms here... but: > > implMethodReturnType = Type.getType(implMethodClassName) > > creates a type whose description is "java/lang/Integer" rather than "Ljava/lang/Integer" i.e. the input is not a type descriptor is just a class name with '.' replaced with '/'. (Perhaps that could be a bug in ASM not throwing an exception on an illegal description?) > > If i do the following then it works: > > if (implKind == MethodHandleInfo.REF_newInvokeSpecial) { > implMethodReturnType = Type.getObjectType(implMethodClassName); > } else { > implMethodReturnType = implMethodAsmType.getReturnType(); > } > > Plus it does not cause additional failures in the lambda lang/invoke tests (same number of tests fail before and after the fix, but i dunno if they are exactly the same tests that fail :-) ). > > Paul. > > On Jun 14, 2013, at 3:55 AM, John Rose wrote: > >> A REF_newInvokeSpecial method handle constant refers to a void-returning method named , but its bytecode behavior returns a reference to the constructed object. >> >> This may require special checks, such as with 'actualReturnType' in AbstractValidatingLambdaMetafactory.java. >> >> There is a missing check in InnerClassLambdaMetafactory.java. Here is a suggested fix (which I have not tested). >> >> ? John >> >> diff --git a/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java b/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java >> --- a/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java >> +++ b/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java >> @@ -112,7 +112,10 @@ >> implMethodDesc = implMethodType.toMethodDescriptorString(); >> Type implMethodAsmType = Type.getMethodType(implMethodDesc); >> implMethodArgumentTypes = implMethodAsmType.getArgumentTypes(); >> - implMethodReturnType = implMethodAsmType.getReturnType(); >> + if (implKind == MethodHandleInfo.REF_newInvokeSpecial) >> + implMethodReturnType = Type.getType(implMethodClassName); >> + else >> + implMethodReturnType = implMethodAsmType.getReturnType(); >> constructorType = invokedType.changeReturnType(Void.TYPE); >> constructorDesc = constructorType.toMethodDescriptorString(); >> lambdaClassName = targetClass.getName().replace('.', '/') + "$$Lambda$" + counter.incrementAndGet(); >> >> >> On May 29, 2013, at 4:25 AM, Maurizio Cimadamore wrote: >> >>> David, Mark, >>> a minimal test case to reproduce the issue is this: >>> >>> interface IntFunction { >>> int m(X x); >>> } >>> >>> class Test { >>> public static void main(String[] args) { >>> IntFunction s = Integer::new; >>> } >>> } >>> >>> >>> Looking at the javap output, in particular at the indy call details, we >>> find this: >>> >>> BootstrapMethods: >>> 0: #15 invokestatic >>> java/lang/invoke/LambdaMetafactory.metaFactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite; >>> Method arguments: >>> #16 invokeinterface IntFunction.m:(Ljava/lang/Object;)I >>> #17 newinvokespecial >>> java/lang/Integer."":(Ljava/lang/String;)V >>> #18 (Ljava/lang/String;)I >>> >>> >>> This seems correct; however, judging from the runtime error, it seems >>> like the metafactory is not unboxing the Integer instance back to int >>> (which is the expected return value of the implemented method). Hence >>> the 292 link failure. Robert, Brian can you confirm? >>> >>> Maurizio >>> >>> >>> On 29/05/13 02:48, David Holmes wrote: >>>> Hi Mark, >>>> >>>> cc'ing lambda-dev. This may be a bug, a version mismatch, or something >>>> else. The lambda-dev folk will know. >>>> >>>> David >>>> >>>> On 29/05/2013 11:04 AM, Mark Derricutt wrote: >>>>> Hi all, >>>>> >>>>> Mark Reinhold suggested I posted this question/bug report to hotspot-dev >>>>> rather than jdk8-dev so here goes. >>>>> >>>>> I have a fairly simple test case using the new streams API: >>>>> >>>>> public static void main(String[] args) { >>>>> List strings = Arrays.asList("1", "2", "3", "4", "5"); >>>>> strings.stream() >>>>> .mapToInt(s -> new Integer(s)) >>>>> .forEach(i -> System.out.println(String.format("int %d", i))); >>>>> } >>>>> >>>>> >>>>> which compiles, runs, and prints out what I expect: >>>>> >>>>> int 1 >>>>> int 2 >>>>> int 3 >>>>> int 4 >>>>> int 5 >>>>> >>>>> >>>>> Given that mapToInt() is returning an IntegerStream wrapping primitive >>>>> ints, the result of my closure is successfully autoboxed down to an int >>>>> and all is happy with the world. >>>>> >>>>> If I change this code to be: >>>>> >>>>> strings.stream() >>>>> .mapToInt(Integer::parseInt) >>>>> .forEach(i -> System.out.println(String.format("int %d", i))); >>>>> >>>>> Again, everything works as expected as Integer::parseInt returns an int, >>>>> so there's no boxing. >>>>> >>>>> Changing this once again to: >>>>> >>>>> strings.stream() >>>>> .mapToInt(Integer::valueOf) >>>>> .forEach(i -> System.out.println(String.format("int %d", i))); >>>>> >>>>> I also see the expected result, Integer::valueOf returns an Integer >>>>> which is then being boxed down to an int. >>>>> >>>>> However, if I change the code to: >>>>> >>>>> strings.stream() >>>>> .mapToInt(Integer::new) >>>>> .forEach(i -> System.out.println(String.format("int %d", i))); >>>>> >>>>> which, if I understand correctly - Integer::new should be returning a >>>>> method handle to the constructor. IntelliJ IDEA 13 autocompletes this >>>>> for me, and hyperlinks to the Integer(String s) constructor, javac >>>>> successfully compiles the code so my -assumption- is that the >>>>> constructor would be called, returning an Integer which is then boxed >>>>> down to an int, however, this is what I get: >>>>> >>>>> Exception in thread "main" java.lang.BootstrapMethodError: call site >>>>> initialization exception >>>>> at java.lang.invoke.CallSite.makeSite(CallSite.java:298) >>>>> at >>>>> java.lang.invoke.MethodHandleNatives.linkCallSite(MethodHandleNatives.java:294) >>>>> >>>>> at com.talios.test.TestJdk.main(TestJdk.java:12) >>>>> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >>>>> at >>>>> sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >>>>> >>>>> at >>>>> sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >>>>> >>>>> at java.lang.reflect.Method.invoke(Method.java:491) >>>>> at >>>>> com.intellij.rt.execution.application.AppMain.main(AppMain.java:120) >>>>> Caused by: java.lang.VerifyError: Bad type on operand stack >>>>> Exception Details: >>>>> Location: >>>>> com/talios/test/TestJdk$$Lambda$1.applyAsInt(Ljava/lang/Object;)I >>>>> @11: ireturn >>>>> Reason: >>>>> Type 'java/lang/Integer' (current frame, stack[0]) is not >>>>> assignable to integer >>>>> Current Frame: >>>>> bci: @11 >>>>> flags: { } >>>>> locals: { 'com/talios/test/TestJdk$$Lambda$1', 'java/lang/Object' } >>>>> stack: { 'java/lang/Integer' } >>>>> Bytecode: >>>>> 0000000: bb00 0e59 2bc0 0010 b700 13ac >>>>> >>>>> at java.lang.Class.getDeclaredConstructors0(Native Method) >>>>> at java.lang.Class.privateGetDeclaredConstructors(Class.java:2536) >>>>> at java.lang.Class.getDeclaredConstructors(Class.java:1928) >>>>> at >>>>> java.lang.invoke.InnerClassLambdaMetafactory$1.run(InnerClassLambdaMetafactory.java:147) >>>>> >>>>> at >>>>> java.lang.invoke.InnerClassLambdaMetafactory$1.run(InnerClassLambdaMetafactory.java:144) >>>>> >>>>> at java.security.AccessController.doPrivileged(Native Method) >>>>> at >>>>> java.lang.invoke.InnerClassLambdaMetafactory.buildCallSite(InnerClassLambdaMetafactory.java:143) >>>>> >>>>> at >>>>> java.lang.invoke.LambdaMetafactory.metaFactory(LambdaMetafactory.java:191) >>>>> at java.lang.invoke.CallSite.makeSite(CallSite.java:283) >>>>> ... 7 more >>>>> >>>>> This is on OSX Mountain Lion, with JDK 8 Build 91. >>>>> >>>>> Have I walked in an obscure corner case of method handle breakage and >>>>> found something new, or is this a new problem? >>>>> >>>>> Cheers, >>>>> Mark >>>>> >>> >> > From tom.hawtin at oracle.com Mon Jun 17 09:36:58 2013 From: tom.hawtin at oracle.com (Tom Hawtin) Date: Mon, 17 Jun 2013 17:36:58 +0100 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51BBBBAA.3090400@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BB8AA1.3080208@oracle.com> <51BBBBAA.3090400@oracle.com> Message-ID: <51BF3B2A.3000806@oracle.com> On 15/06/2013 01:56, Brian Goetz wrote: > Yeah, but once you make one not-serializable, there's no way to > un-not-serializable it. (Serializable is a misnomer; really what we > have is the ability to say "not serialization-hostile.") So if any ever > need to be serializable, we either need to make them all so, or have two > versions of each factory/combinator. Awful options all around. Certainly for a subclassable type, making it Serializable after fcs breaks expectations that can reasonably be made. I don't see your point when considering "package private", private or final classes. Like it or somewhat more likely not, once you make a type in an API package serialisable it is in the public API (except Swing). Even if it isn't in an API package, people (possibly the Java Class Library) will still use it. As serialisation stands (and it's not likely anyone is going to be keen on messing with it) you may want an API serial proxy to go along with your real hidden implementation. Tom From henry.jen at oracle.com Mon Jun 17 10:49:22 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Mon, 17 Jun 2013 17:49:22 +0000 Subject: hg: lambda/lambda/jdk: Cleanup: spec vs apiNote Message-ID: <20130617175004.D33A64827D@hg.openjdk.java.net> Changeset: 18a14fb2b9b2 Author: henryjen Date: 2013-06-17 10:49 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/18a14fb2b9b2 Cleanup: spec vs apiNote ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Map.java From brian.goetz at oracle.com Mon Jun 17 11:26:44 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Mon, 17 Jun 2013 18:26:44 +0000 Subject: hg: lambda/lambda/jdk: Remove or make private canned merge functions in Collectors Message-ID: <20130617182710.AE20248281@hg.openjdk.java.net> Changeset: 21bd25407ffc Author: briangoetz Date: 2013-06-17 14:26 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/21bd25407ffc Remove or make private canned merge functions in Collectors ! src/share/classes/java/util/Map.java ! src/share/classes/java/util/stream/Collectors.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/SortedOpTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java From henry.jen at oracle.com Mon Jun 17 11:37:14 2013 From: henry.jen at oracle.com (Henry Jen) Date: Mon, 17 Jun 2013 11:37:14 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51BF3B2A.3000806@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BB8AA1.3080208@oracle.com> <51BBBBAA.3090400@oracle.com> <51BF3B2A.3000806@oracle.com> Message-ID: On Jun 17, 2013, at 9:36 AM, Tom Hawtin wrote: > On 15/06/2013 01:56, Brian Goetz wrote: >> Yeah, but once you make one not-serializable, there's no way to >> un-not-serializable it. (Serializable is a misnomer; really what we >> have is the ability to say "not serialization-hostile.") So if any ever >> need to be serializable, we either need to make them all so, or have two >> versions of each factory/combinator. Awful options all around. > > Certainly for a subclassable type, making it Serializable after fcs > breaks expectations that can reasonably be made. I don't see your point > when considering "package private", private or final classes. > > Like it or somewhat more likely not, once you make a type in an API > package serialisable it is in the public API (except Swing). Even if it > isn't in an API package, people (possibly the Java Class Library) will > still use it. As serialisation stands (and it's not likely anyone is > going to be keen on messing with it) you may want an API serial proxy to > go along with your real hidden implementation. > As Brian said, we need to keep the comparator serializable. NullComparator is a simple wrapper, which is package private and we can go further make it final class. I am not sure what do you mean by API serial proxy, my understanding of the concern is that we want to hide the implementation detail from serialization. Seems to me, that is the same as we distill the implementation to it's essential minimum. Isn't it? For this case, it would be a boolean and the original Comparator, and that's the latest implementation. Let me know if I miss something, and I am open to better options. Cheers, Henry From brian.goetz at oracle.com Mon Jun 17 13:32:22 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Mon, 17 Jun 2013 20:32:22 +0000 Subject: hg: lambda/lambda/jdk: 2 new changesets Message-ID: <20130617203254.7D34048287@hg.openjdk.java.net> Changeset: 52eebe2527c3 Author: briangoetz Date: 2013-06-17 15:58 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/52eebe2527c3 More Collector cleanups from reviews ! src/share/classes/java/util/stream/Collector.java ! src/share/classes/java/util/stream/Collectors.java ! src/share/classes/java/util/stream/DelegatingStream.java ! src/share/classes/java/util/stream/ReduceOps.java ! src/share/classes/java/util/stream/ReferencePipeline.java ! src/share/classes/java/util/stream/Stream.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/GroupByOpTest.java Changeset: dfdfae8aab5d Author: briangoetz Date: 2013-06-17 16:06 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/dfdfae8aab5d Make non-seed reduce, min, and max return Optional ! src/share/classes/java/util/stream/Collectors.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java From aruld at acm.org Mon Jun 17 16:13:08 2013 From: aruld at acm.org (Arul Dhesiaseelan) Date: Mon, 17 Jun 2013 13:13:08 -1000 Subject: groupingByConcurrent javadoc shows an example use that does not require a map factory Message-ID: Looks like this example in Collectors javadoc needs to be corrected for groupingByConcurrent that does not take a map factory? ConcurrentMap> namesByCity = people.stream().collect(groupingByConcurrent(Person::getCity, TreeMap::new, mapping(Person::getLastName, toSet()))); map factory should not be included in this example, as it uses the default factory. - Arul From brian.goetz at oracle.com Mon Jun 17 16:21:59 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Mon, 17 Jun 2013 19:21:59 -0400 Subject: groupingByConcurrent javadoc shows an example use that does not require a map factory In-Reply-To: References: Message-ID: <51BF9A17.5050203@oracle.com> No, the default factory is HashMap::new. This asks for a TreeMap, which has the additional property of having a sorted encounter order for keys. On 6/17/2013 7:13 PM, Arul Dhesiaseelan wrote: > Looks like this example in Collectors javadoc needs to be corrected for > groupingByConcurrent that does not take a map factory? > > ConcurrentMap> namesByCity > = > people.stream().collect(groupingByConcurrent(Person::getCity, TreeMap::new, > > mapping(Person::getLastName, toSet()))); > > map factory should not be included in this example, as it uses the default > factory. > > - Arul > From aruld at acm.org Mon Jun 17 17:11:52 2013 From: aruld at acm.org (Arul Dhesiaseelan) Date: Mon, 17 Jun 2013 14:11:52 -1000 Subject: groupingByConcurrent javadoc shows an example use that does not require a map factory In-Reply-To: <51BF9A17.5050203@oracle.com> References: <51BF9A17.5050203@oracle.com> Message-ID: Ok, this example fails to compile in build 94 with incompatible types error, since TreeMap is not a ConcurrentMap, so this example still needs correction, no? java: incompatible types: Cannot instantiate inference variables T because of an inference loop On Mon, Jun 17, 2013 at 1:21 PM, Brian Goetz wrote: > No, the default factory is HashMap::new. This asks for a TreeMap, which > has the additional property of having a sorted encounter order for keys. > > > On 6/17/2013 7:13 PM, Arul Dhesiaseelan wrote: > >> Looks like this example in Collectors javadoc needs to be corrected for >> groupingByConcurrent that does not take a map factory? >> >> ConcurrentMap> namesByCity >> = >> people.stream().collect(**groupingByConcurrent(Person::**getCity, >> TreeMap::new, >> >> mapping(Person::getLastName, toSet()))); >> >> map factory should not be included in this example, as it uses the default >> factory. >> >> - Arul >> >> From brian.goetz at oracle.com Mon Jun 17 17:22:53 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Mon, 17 Jun 2013 20:22:53 -0400 Subject: groupingByConcurrent javadoc shows an example use that does not require a map factory In-Reply-To: References: <51BF9A17.5050203@oracle.com> Message-ID: <51BFA85D.9030108@oracle.com> Ah, OK. It should be ConcurrentSkipListMap (the concurrent Map impl with sorted keys.) On 6/17/2013 8:11 PM, Arul Dhesiaseelan wrote: > Ok, this example fails to compile in build 94 with incompatible types > error, since TreeMap is not a ConcurrentMap, so this example still needs > correction, no? > > java: incompatible types: Cannot instantiate inference variables T > because of an inference loop > > > On Mon, Jun 17, 2013 at 1:21 PM, Brian Goetz > wrote: > > No, the default factory is HashMap::new. This asks for a TreeMap, > which has the additional property of having a sorted encounter order > for keys. > > > On 6/17/2013 7:13 PM, Arul Dhesiaseelan wrote: > > Looks like this example in Collectors javadoc needs to be > corrected for > groupingByConcurrent that does not take a map factory? > > ConcurrentMap> namesByCity > = > people.stream().collect(__groupingByConcurrent(Person::__getCity, TreeMap::new, > > mapping(Person::getLastName, toSet()))); > > map factory should not be included in this example, as it uses > the default > factory. > > - Arul > > From robert.field at oracle.com Mon Jun 17 20:19:16 2013 From: robert.field at oracle.com (Robert Field) Date: Mon, 17 Jun 2013 20:19:16 -0700 Subject: RFR 8016761: Lambda metafactory: incorrect type conversion of constructor method handle Message-ID: <51BFD1B4.9070402@oracle.com> Please review the fix for CR: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=8016761 Webrev: http://cr.openjdk.java.net/~rfield/8016761/ From john.r.rose at oracle.com Mon Jun 17 22:26:39 2013 From: john.r.rose at oracle.com (John Rose) Date: Mon, 17 Jun 2013 22:26:39 -0700 Subject: RFR 8016761: Lambda metafactory: incorrect type conversion of constructor method handle In-Reply-To: <51BFD1B4.9070402@oracle.com> References: <51BFD1B4.9070402@oracle.com> Message-ID: <4E38CE37-62D4-4411-B59D-E2EAF98F7070@oracle.com> On Jun 17, 2013, at 8:19 PM, Robert Field wrote: > Please review the fix for CR: > > http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=8016761 > > Webrev: > > http://cr.openjdk.java.net/~rfield/8016761/ I suggest a more end-to-end test: Call s.m on a couple of test operands. That may flush out problems not detected until the m adapter is run. ? John From robert.field at oracle.com Mon Jun 17 22:51:23 2013 From: robert.field at oracle.com (Robert Field) Date: Mon, 17 Jun 2013 22:51:23 -0700 Subject: RFR 8016761: Lambda metafactory: incorrect type conversion of constructor method handle Message-ID: OK, will do. Thanks, Robert John Rose wrote: >On Jun 17, 2013, at 8:19 PM, Robert Field wrote: > >> Please review the fix for CR: >> >> http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=8016761 >> >> Webrev: >> >> http://cr.openjdk.java.net/~rfield/8016761/ > >I suggest a more end-to-end test: Call s.m on a couple of test operands. That may flush out problems not detected until the m adapter is run. > >? John From peter.levart at gmail.com Tue Jun 18 00:29:30 2013 From: peter.levart at gmail.com (Peter Levart) Date: Tue, 18 Jun 2013 09:29:30 +0200 Subject: IncompatibleClassChangeError example In-Reply-To: <51B49E27.7090300@gmail.com> References: <51B49E27.7090300@gmail.com> Message-ID: <51C00C5A.1030509@gmail.com> Just a reminder that the following problem is still present... Regards, Peter On 06/09/2013 05:24 PM, Peter Levart wrote: > Hi, > > When I compile and run the following program with the latest tip of > lambda repo: > > > import java.util.function.Function; > import java.util.function.Supplier; > > public class ICCEBug { > > interface Value extends Supplier { > default Value map(Function > mapper) { > return new SuppliedValue<>(() -> mapper.apply(this.get())); > } > } > > static class SuppliedValue implements Value { > private final Supplier supplier; > > SuppliedValue(Supplier supplier) { > this.supplier = supplier; > } > > @Override > public T get() { > return supplier.get(); > } > } > > public static void main(String[] args) { > Value name = () -> "Peter"; > Value sentence = name.map(nm -> "Hello " + nm + "!"); > System.out.println(sentence.get()); > } > } > > > > ... I get the following exception: > > Exception in thread "main" java.lang.IncompatibleClassChangeError: > Class ICCEBug$$Lambda$2 does not implement the requested interface > ICCEBug$Value > at ICCEBug$Value.lambda$0(ICCEBug.java:17) > at ICCEBug$Value$$Lambda$3.get(Unknown Source) > at ICCEBug$SuppliedValue.get(ICCEBug.java:30) > at ICCEBug.main(ICCEBug.java:37) > > > > It looks like something is not compiled correctly. > > Regards, Peter > From john.r.rose at oracle.com Tue Jun 18 01:23:56 2013 From: john.r.rose at oracle.com (John Rose) Date: Tue, 18 Jun 2013 01:23:56 -0700 Subject: RFR 8016761: Lambda metafactory: incorrect type conversion of constructor method handle In-Reply-To: References: Message-ID: On Jun 17, 2013, at 10:51 PM, Robert Field wrote: > OK, will do. Good; thanks. You can list me as a reviewer. ? John From mcnepp02 at googlemail.com Tue Jun 18 02:11:41 2013 From: mcnepp02 at googlemail.com (Gernot Neppert) Date: Tue, 18 Jun 2013 11:11:41 +0200 Subject: Question reg. holding Locks during invocation of Lambdas Message-ID: Hi all, I noticed that ConcurrentHashMap.computeIfAbsent() invokes the user-supplied callback while being in a synchronized block. One of the rules I stick to in programming is "Don't invoke a user-supplied callback from a library while holding a Lock". (because it can lead to nasty deadlocks). If I understand it correctly, the purpose of computeIfAbsent() is delaying the invocation of a possibly lengthy factory-expression until it has been determined that a mapping for the key is not already present. Thus, shouldn't the callback better be called outside any held Locks? For those interested in more details: A while back I wrote a class "CacheMap" that serves as a drop-in-replacement for java.util.Map. Its get(Object key) method invokes a uses-supplied callback if a mapping is not already present. In the implementation I went to great lengths to ensure that no Locks are held while invoking the callback while at the same time guaranteeing consistency in a multi-threaded scenario. (The Map-wide Lock is only held for a short duration to atomically check for the key and put a temporary "factory" object in the internal Map. This factory object then uses wait/notify to ensure that subsequent threads requiring the same key will block until the callback has been invoked). So I know it's possible to do it "correctly". Now I'd be reluctant to replace my "CacheMap" with JDK's "ConcurrentHashMap" because of the possible deadlocks waiting to happen. From dl at cs.oswego.edu Tue Jun 18 05:09:19 2013 From: dl at cs.oswego.edu (Doug Lea) Date: Tue, 18 Jun 2013 08:09:19 -0400 Subject: Question reg. holding Locks during invocation of Lambdas In-Reply-To: References: Message-ID: <51C04DEF.7090406@cs.oswego.edu> On 06/18/13 05:11, Gernot Neppert wrote: > Hi all, > > I noticed that ConcurrentHashMap.computeIfAbsent() invokes the > user-supplied callback while being in a synchronized block. > > One of the rules I stick to in programming is "Don't invoke a user-supplied > callback from a library while holding a Lock". > (because it can lead to nasty deadlocks). Yes, this is exactly why we did not originally provide such a method in ConcurrentMap. But now we know that this was the wrong choice. Empirical reports imply that many more bugs are caused by people not correctly maintaining atomicity when they don't have this method than would be caused by supporting it and thus making it easier to encounter deadlock. (See for example Shacham et al's OOPSLA 2011 paper at http://www.cs.tau.ac.il/~ohads/) -Doug > > If I understand it correctly, the purpose of computeIfAbsent() is delaying > the invocation of a possibly lengthy factory-expression until it has been > determined that a mapping for the key is not already present. > > Thus, shouldn't the callback better be called outside any held Locks? > > For those interested in more details: > A while back I wrote a class "CacheMap" that serves as a > drop-in-replacement for java.util.Map. Its get(Object key) method invokes a > uses-supplied callback if a mapping is not already present. > In the implementation I went to great lengths to ensure that no Locks are > held while invoking the callback while at the same time guaranteeing > consistency in a multi-threaded scenario. > (The Map-wide Lock is only held for a short duration to atomically check > for the key and put a temporary "factory" object in the internal Map. This > factory object then uses wait/notify to ensure that subsequent threads > requiring the same key will block until the callback has been invoked). > So I know it's possible to do it "correctly". Now I'd be reluctant to > replace my "CacheMap" with JDK's "ConcurrentHashMap" because of the > possible deadlocks waiting to happen. > From paul.sandoz at oracle.com Tue Jun 18 05:40:03 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Tue, 18 Jun 2013 12:40:03 +0000 Subject: hg: lambda/lambda/jdk: Remove Streams.zip. Message-ID: <20130618124032.76707482AD@hg.openjdk.java.net> Changeset: 569088178418 Author: psandoz Date: 2013-06-18 14:39 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/569088178418 Remove Streams.zip. ! src/share/classes/java/util/stream/Streams.java - test/java/util/stream/test/org/openjdk/tests/java/util/stream/ZipOpTest.java From mcnepp02 at googlemail.com Tue Jun 18 07:43:18 2013 From: mcnepp02 at googlemail.com (Gernot Neppert) Date: Tue, 18 Jun 2013 16:43:18 +0200 Subject: Question reg. holding Locks during invocation of Lambdas In-Reply-To: <51C04DEF.7090406@cs.oswego.edu> References: <51C04DEF.7090406@cs.oswego.edu> Message-ID: Hi Doug, thanks for the answer. However, you seem to answer only why "computeIfAbsent" was not initially included in ConcurrentMap's interface and why it has been included now. The point I was trying to make is that you can have it both ways: 1.) implement correct atomic behaviour of the entire compound operation. 2.) Call the user-supplied callback without holding any internal Locks. ConcurrentHashMap, however, chooses to obey only to 1.) I'd simply like to know the reason for this decision. For example, "Too high a performance penalty for other operations" would be an acceptable answer! 2013/6/18 Doug Lea

> On 06/18/13 05:11, Gernot Neppert wrote: > > Hi all, > > > > I noticed that ConcurrentHashMap.computeIfAbsent() invokes the > > user-supplied callback while being in a synchronized block. > > > > One of the rules I stick to in programming is "Don't invoke a > user-supplied > > callback from a library while holding a Lock". > > (because it can lead to nasty deadlocks). > > Yes, this is exactly why we did not originally provide > such a method in ConcurrentMap. But now we know that this > was the wrong choice. Empirical reports imply that many more > bugs are caused by people not correctly maintaining atomicity > when they don't have this method than would be caused by > supporting it and thus making it easier to encounter deadlock. > > (See for example Shacham et al's OOPSLA 2011 paper > at http://www.cs.tau.ac.il/~ohads/) > > -Doug > > > > > > If I understand it correctly, the purpose of computeIfAbsent() is > delaying > > the invocation of a possibly lengthy factory-expression until it has been > > determined that a mapping for the key is not already present. > > > > Thus, shouldn't the callback better be called outside any held Locks? > > > > For those interested in more details: > > A while back I wrote a class "CacheMap" that serves as a > > drop-in-replacement for java.util.Map. Its get(Object key) method > invokes a > > uses-supplied callback if a mapping is not already present. > > In the implementation I went to great lengths to ensure that no Locks are > > held while invoking the callback while at the same time guaranteeing > > consistency in a multi-threaded scenario. > > (The Map-wide Lock is only held for a short duration to atomically check > > for the key and put a temporary "factory" object in the internal Map. > This > > factory object then uses wait/notify to ensure that subsequent threads > > requiring the same key will block until the callback has been invoked). > > So I know it's possible to do it "correctly". Now I'd be reluctant to > > replace my "CacheMap" with JDK's "ConcurrentHashMap" because of the > > possible deadlocks waiting to happen. > > > > > From brian.goetz at oracle.com Tue Jun 18 08:47:23 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Tue, 18 Jun 2013 15:47:23 +0000 Subject: hg: lambda/lambda/jdk: More renamings in Collector API Message-ID: <20130618154758.4DE1F482BC@hg.openjdk.java.net> Changeset: dc643a58768e Author: briangoetz Date: 2013-06-18 11:47 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/dc643a58768e More renamings in Collector API ! src/share/classes/java/util/stream/Collector.java ! src/share/classes/java/util/stream/Collectors.java ! src/share/classes/java/util/stream/ReferencePipeline.java From henry.jen at oracle.com Tue Jun 18 09:38:55 2013 From: henry.jen at oracle.com (Henry Jen) Date: Tue, 18 Jun 2013 09:38:55 -0700 Subject: hg: lambda/lambda/jdk: Remove Streams.zip. In-Reply-To: <20130618124032.76707482AD@hg.openjdk.java.net> References: <20130618124032.76707482AD@hg.openjdk.java.net> Message-ID: <13B85D15-69AD-46D2-B4CE-6F19AE74AAC6@oracle.com> I have moved concat in my repo, so Streams is now implementation supports and will be package private. Cheers, Henry On Jun 18, 2013, at 5:40 AM, paul.sandoz at oracle.com wrote: > Changeset: 569088178418 > Author: psandoz > Date: 2013-06-18 14:39 +0200 > URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/569088178418 > > Remove Streams.zip. > > ! src/share/classes/java/util/stream/Streams.java > - test/java/util/stream/test/org/openjdk/tests/java/util/stream/ZipOpTest.java > > From mike.duigou at oracle.com Tue Jun 18 10:45:36 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Tue, 18 Jun 2013 17:45:36 +0000 Subject: hg: lambda/lambda/jdk: better handling of ISE in replaceAll Message-ID: <20130618174554.B60AF482C1@hg.openjdk.java.net> Changeset: 29731c47f379 Author: mduigou Date: 2013-06-18 10:45 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/29731c47f379 better handling of ISE in replaceAll ! src/share/classes/java/util/Map.java From brian.goetz at oracle.com Tue Jun 18 13:23:19 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Tue, 18 Jun 2013 20:23:19 +0000 Subject: hg: lambda/lambda/jdk: Remove duplicate test Message-ID: <20130618202332.C541C482D2@hg.openjdk.java.net> Changeset: 649d7fd5dade Author: briangoetz Date: 2013-06-18 16:23 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/649d7fd5dade Remove duplicate test - test/java/util/StringJoinerTest.java From tom.hawtin at oracle.com Tue Jun 18 15:38:39 2013 From: tom.hawtin at oracle.com (Tom Hawtin) Date: Tue, 18 Jun 2013 23:38:39 +0100 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BB8AA1.3080208@oracle.com> <51BBBBAA.3090400@oracle.com> <51BF3B2A.3000806@oracle.com> Message-ID: <51C0E16F.60105@oracle.com> On 17/06/2013 19:37, Henry Jen wrote: > I am not sure what do you mean by API serial proxy, my understanding of the concern is that we want to hide the implementation detail from serialization. Seems to me, that is the same as we distill the implementation to it's essential minimum. Isn't it? For this case, it would be a boolean and the original Comparator, and that's the latest implementation. A serial proxy is a class that which the serialisation mechanism works on to work out what to write into the stream, but isn't the actual working class. When serialised the working class returns a serial proxy from its writeReplace, which is actually serialised. When deserialised the serial proxy replaces itself with a working class from readResolve. So for example, if we find out HotSpot works better if we have two different implementations for returning sign +1 and -1 (because that determines where the calling code immediately jumps to), then we can do that with three classes, one of which being a serial proxy with the original implementation name and fields. Similarly if we found that the target comparator was almost always the same type and wanted to combine the comparators when used in sequence, we could have a serial proxy handle that. On a different topic, I wonder if it's fractionally better to write the compare method as: return a==b ? 0 : a==null ? (nullsFirst ? -1 : 1) : real.compare(a, b); Also as this class considers all null to be a single value, I think that should be nullFirst instead of nullsFirst. Tom From henry.jen at oracle.com Tue Jun 18 16:04:54 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Tue, 18 Jun 2013 23:04:54 +0000 Subject: hg: lambda/lambda/jdk: Streams.zip has been removed Message-ID: <20130618230506.BE060482EF@hg.openjdk.java.net> Changeset: dcdbe791807e Author: henryjen Date: 2013-06-18 16:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/dcdbe791807e Streams.zip has been removed ! test/java/util/stream/Streams/BasicTest.java From henry.jen at oracle.com Tue Jun 18 16:07:02 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Tue, 18 Jun 2013 23:07:02 +0000 Subject: hg: lambda/lambda/jdk: 2 new changesets Message-ID: <20130618230725.C63C1482F2@hg.openjdk.java.net> Changeset: 64928feb1bc5 Author: henryjen Date: 2013-06-18 16:05 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/64928feb1bc5 Use enum for terminal test scenarios Contributed-by: paul.sandoz at oracle.com ! test/java/util/stream/bootlib/java/util/stream/OpTestCase.java Changeset: 2b2909b47556 Author: henryjen Date: 2013-06-18 16:05 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/2b2909b47556 Move Streams.concat to be static methods ! src/share/classes/java/util/stream/DoubleStream.java ! src/share/classes/java/util/stream/IntStream.java ! src/share/classes/java/util/stream/LongStream.java ! src/share/classes/java/util/stream/Stream.java ! src/share/classes/java/util/stream/Streams.java ! test/java/util/stream/Stream/EmployeeStreamTest.java ! test/java/util/stream/Stream/IntegerStreamTest.java ! test/java/util/stream/Stream/StringBuilderStreamTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatOpTest.java From john.r.rose at oracle.com Tue Jun 18 16:40:02 2013 From: john.r.rose at oracle.com (John Rose) Date: Tue, 18 Jun 2013 16:40:02 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51C0E16F.60105@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BB8AA1.3080208@oracle.com> <51BBBBAA.3090400@oracle.com> <51BF3B2A.3000806@oracle.com> <51C0E16F.60105@oracle.com> Message-ID: On Jun 18, 2013, at 3:38 PM, Tom Hawtin wrote: > On a different topic, I wonder if it's fractionally better to write the > compare method as: > > return > a==b ? 0 : > a==null ? (nullsFirst ? -1 : 1) : > real.compare(a, b); Putting my C2 hat on... It is likely to be fractionally worse in many cases. A 2-way pointer comparison is much more likely to remain in the generated code than the null comparisons (with 'a' and then 'b'). Tests of the form "x == null" are very likely to value-number (i.e., merge) with other tests in the same control flow, and such tests can also be merged (as implicit null checks) into dominating or trailing memory references "x.foo". Adding the a==b?0 part would likely prevent a null check from being merged with a preceding "x.foo" reference, if there were one available. Tests of the form "x == y" are less common, although if the real.compare call is inlined, there may be an equivalent short-circuit test inside the inlined method. Or maybe not. Omitting the hoisted a==b?0 would allow the real.compare method to decide whether or not to issue the pointer comparison. Even though a pointer comparison is very cheap, it is much more expensive than nothing at all. Worst case is the cost of the extra check is not amortized by work avoided by taken branches (the ?0 part). This would occur when the comparator is used on a collection of all-distinct pointers. That seems like a distinct possibility. Rules of thumb for Java coders: Simpler is better. Null checks are cheap. ? John From dl at cs.oswego.edu Tue Jun 18 17:02:03 2013 From: dl at cs.oswego.edu (Doug Lea) Date: Tue, 18 Jun 2013 20:02:03 -0400 Subject: Question reg. holding Locks during invocation of Lambdas In-Reply-To: References: <51C04DEF.7090406@cs.oswego.edu> Message-ID: <51C0F4FB.1060401@cs.oswego.edu> On 06/18/13 10:43, Gernot Neppert wrote: > Hi Doug, thanks for the answer. However, you seem to answer only why > "computeIfAbsent" was not initially included in ConcurrentMap's interface and > why it has been included now. > The point I was trying to make is that you can have it both ways: > 1.) implement correct atomic behaviour of the entire compound operation. > 2.) Call the user-supplied callback without holding any internal Locks. > I'd simply like to know the reason for this decision. For example, "Too high a > performance penalty for other operations" would be an acceptable answer! Ultimately yes. the use of a global lock would negate the Concurrentness of most ConcurrentMaps. (We do document use of locks here. And people who would rather for example use reservation sentinels can still get these effects without locking using regular putIfAbsent/replace mechanics.) -Doug > > 2013/6/18 Doug Lea
> > > On 06/18/13 05:11, Gernot Neppert wrote: > > Hi all, > > > > I noticed that ConcurrentHashMap.computeIfAbsent() invokes the > > user-supplied callback while being in a synchronized block. > > > > One of the rules I stick to in programming is "Don't invoke a user-supplied > > callback from a library while holding a Lock". > > (because it can lead to nasty deadlocks). > > Yes, this is exactly why we did not originally provide > such a method in ConcurrentMap. But now we know that this > was the wrong choice. Empirical reports imply that many more > bugs are caused by people not correctly maintaining atomicity > when they don't have this method than would be caused by > supporting it and thus making it easier to encounter deadlock. > > (See for example Shacham et al's OOPSLA 2011 paper > at http://www.cs.tau.ac.il/~ohads/) > > -Doug > > > > > > If I understand it correctly, the purpose of computeIfAbsent() is delaying > > the invocation of a possibly lengthy factory-expression until it has been > > determined that a mapping for the key is not already present. > > > > Thus, shouldn't the callback better be called outside any held Locks? > > > > For those interested in more details: > > A while back I wrote a class "CacheMap" that serves as a > > drop-in-replacement for java.util.Map. Its get(Object key) method invokes a > > uses-supplied callback if a mapping is not already present. > > In the implementation I went to great lengths to ensure that no Locks are > > held while invoking the callback while at the same time guaranteeing > > consistency in a multi-threaded scenario. > > (The Map-wide Lock is only held for a short duration to atomically check > > for the key and put a temporary "factory" object in the internal Map. This > > factory object then uses wait/notify to ensure that subsequent threads > > requiring the same key will block until the callback has been invoked). > > So I know it's possible to do it "correctly". Now I'd be reluctant to > > replace my "CacheMap" with JDK's "ConcurrentHashMap" because of the > > possible deadlocks waiting to happen. > > > > > From mike.duigou at oracle.com Tue Jun 18 21:05:15 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 19 Jun 2013 04:05:15 +0000 Subject: hg: lambda/lambda/corba: 2 new changesets Message-ID: <20130619040518.CFDAE48307@hg.openjdk.java.net> Changeset: 22f5d7f261d9 Author: katleman Date: 2013-06-06 09:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/corba/rev/22f5d7f261d9 Added tag jdk8-b93 for changeset 8dc9d7ccbb2d ! .hgtags Changeset: 08e436473edb Author: mduigou Date: 2013-06-18 10:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/corba/rev/08e436473edb Merge ! .hgtags - .jcheck/conf From mike.duigou at oracle.com Tue Jun 18 21:05:16 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 19 Jun 2013 04:05:16 +0000 Subject: hg: lambda/lambda/jaxws: 2 new changesets Message-ID: <20130619040525.9525748309@hg.openjdk.java.net> Changeset: 254c53fd97ab Author: katleman Date: 2013-06-06 09:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxws/rev/254c53fd97ab Added tag jdk8-b93 for changeset 7386eca865e1 ! .hgtags Changeset: f2e56f100ecf Author: mduigou Date: 2013-06-18 10:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxws/rev/f2e56f100ecf Merge ! .hgtags - .jcheck/conf From mike.duigou at oracle.com Tue Jun 18 21:05:16 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 19 Jun 2013 04:05:16 +0000 Subject: hg: lambda/lambda/jaxp: 6 new changesets Message-ID: <20130619040535.71AFB4830A@hg.openjdk.java.net> Changeset: 40da96cab40e Author: katleman Date: 2013-06-06 09:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/40da96cab40e Added tag jdk8-b93 for changeset d583a491d63c ! .hgtags Changeset: f117a66f337c Author: lana Date: 2013-06-03 16:09 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/f117a66f337c Merge Changeset: 5b958f0a5498 Author: joehw Date: 2013-06-04 09:35 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/5b958f0a5498 8015630: Remove default restriction settings of jaxp 1.5 properties in JDK8 Reviewed-by: alanb ! src/com/sun/org/apache/xalan/internal/XalanConstants.java ! src/com/sun/org/apache/xalan/internal/xsltc/trax/TransformerFactoryImpl.java ! src/com/sun/org/apache/xerces/internal/impl/Constants.java ! src/com/sun/org/apache/xerces/internal/jaxp/validation/XMLSchemaFactory.java Changeset: e996ea806630 Author: lana Date: 2013-06-04 21:33 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/e996ea806630 Merge Changeset: c84658e1740d Author: lana Date: 2013-06-10 16:59 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/c84658e1740d Merge Changeset: ae467ce203a8 Author: mduigou Date: 2013-06-18 10:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jaxp/rev/ae467ce203a8 Merge ! .hgtags - .jcheck/conf From mike.duigou at oracle.com Tue Jun 18 21:05:20 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 19 Jun 2013 04:05:20 +0000 Subject: hg: lambda/lambda/nashorn: 27 new changesets Message-ID: <20130619040543.8D9574830B@hg.openjdk.java.net> Changeset: e857ab684db0 Author: cl Date: 2013-06-06 20:48 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/e857ab684db0 Added tag jdk8-b93 for changeset ddbf41575a2b ! .hgtags Changeset: 7e105c2f3167 Author: lana Date: 2013-06-03 16:10 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/7e105c2f3167 Merge Changeset: d2bd881976b5 Author: lana Date: 2013-06-04 21:38 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/d2bd881976b5 Merge Changeset: 66b2fde90c9d Author: jlaskey Date: 2013-05-29 16:23 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/66b2fde90c9d 8015636: Add more typed arrays code coverage tests. Reviewed-by: sundar Contributed-by: james.laskey at oracle.com + test/script/basic/typedarrays.js Changeset: eda227663eda Author: sundar Date: 2013-05-30 16:49 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/eda227663eda 8015353: Date.parse illegal string parsing issues Reviewed-by: jlaskey, lagergren - src/jdk/nashorn/internal/objects/DateParser.java ! src/jdk/nashorn/internal/objects/NativeDate.java + src/jdk/nashorn/internal/parser/DateParser.java + test/script/basic/JDK-8015353.js Changeset: 818946884410 Author: attila Date: 2013-05-31 12:56 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/818946884410 8015693: reduce NodeLiteralNode to NullLiteralNode Reviewed-by: jlaskey, lagergren ! src/jdk/nashorn/internal/ir/LiteralNode.java Changeset: d8a7727a519e Author: attila Date: 2013-05-31 12:57 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/d8a7727a519e 8015684: FieldObjectCreator.putField ignores getValueType Reviewed-by: jlaskey, lagergren ! src/jdk/nashorn/internal/codegen/CodeGenerator.java ! src/jdk/nashorn/internal/codegen/FieldObjectCreator.java Changeset: cab639125b98 Author: attila Date: 2013-05-31 12:57 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/cab639125b98 8015674: CodeGenerator.initSymbols mutates a list Reviewed-by: jlaskey, lagergren ! src/jdk/nashorn/internal/codegen/CodeGenerator.java Changeset: 11b81fa7125a Author: attila Date: 2013-05-31 12:58 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/11b81fa7125a 8015673: Type for :e symbol is wrong Reviewed-by: jlaskey, lagergren ! src/jdk/nashorn/internal/codegen/Attr.java ! src/jdk/nashorn/internal/codegen/CompilerConstants.java Changeset: b4e6cc05ce09 Author: sundar Date: 2013-05-31 17:39 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/b4e6cc05ce09 8012164: Error.stack needs trimming Reviewed-by: lagergren, jlaskey ! src/jdk/nashorn/internal/objects/NativeError.java + test/script/basic/JDK-8012164.js + test/script/basic/JDK-8012164.js.EXPECTED ! test/script/basic/NASHORN-108.js.EXPECTED ! test/script/basic/NASHORN-109.js.EXPECTED ! test/script/basic/errorstack.js.EXPECTED Changeset: 64250b3a2f2a Author: jlaskey Date: 2013-05-31 13:04 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/64250b3a2f2a 8015727: Thread safe print function Reviewed-by: sundar Contributed-by: james.laskey at oracle.com ! src/jdk/nashorn/internal/objects/Global.java Changeset: 295c91f5fdde Author: sundar Date: 2013-06-03 15:58 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/295c91f5fdde 8015345: Function("}),print('test'),({") should throw SyntaxError Reviewed-by: lagergren, hannesw, jlaskey ! src/jdk/nashorn/internal/objects/NativeFunction.java ! src/jdk/nashorn/internal/parser/Parser.java + test/script/basic/JDK-8015345.js + test/script/basic/JDK-8015345.js.EXPECTED ! test/script/basic/funcconstructor.js.EXPECTED Changeset: 08a8fda6c0bf Author: jlaskey Date: 2013-06-03 08:34 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/08a8fda6c0bf 8015741: Need a global.load function that starts with a new global scope. Reviewed-by: sundar, lagergren Contributed-by: james.laskey at oracle.com ! src/jdk/nashorn/internal/objects/Global.java ! src/jdk/nashorn/internal/runtime/Context.java + test/script/basic/JDK-8015741.js + test/script/basic/JDK-8015741.js.EXPECTED Changeset: 2df08f4c531d Author: jlaskey Date: 2013-06-03 11:16 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/2df08f4c531d 8015796: Race condition in RuntimeCallsites Reviewed-by: lagergren, attila Contributed-by: james.laskey at oracle.com ! src/jdk/nashorn/internal/codegen/RuntimeCallSite.java Changeset: 0946c8a60f39 Author: jlaskey Date: 2013-06-03 12:57 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/0946c8a60f39 8015814: loadWithNewGlobal needs to wrap createGlobal in AccessController.doPrivileged Reviewed-by: sundar Contributed-by: james.laskey at oracle.com ! src/jdk/nashorn/internal/runtime/Context.java Changeset: 78113cda23bf Author: sundar Date: 2013-06-04 17:33 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/78113cda23bf 8015855: test/script/basic/JDK-8012164.js fails on Windows Reviewed-by: hannesw, lagergren, jlaskey ! test/script/basic/JDK-8012164.js Changeset: c70f60578385 Author: sundar Date: 2013-06-04 22:31 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/c70f60578385 8015830: Javascript mapping of ScriptEngine bindings does not expose keys Reviewed-by: jlaskey, lagergren ! src/jdk/nashorn/api/scripting/ScriptObjectMirror.java ! src/jdk/nashorn/internal/runtime/ScriptObject.java ! src/jdk/nashorn/internal/runtime/ScriptRuntime.java + test/script/basic/JDK-8015830.js + test/script/basic/JDK-8015830.js.EXPECTED Changeset: 62b096f7bac3 Author: sundar Date: 2013-06-05 12:08 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/62b096f7bac3 8015945: loadWithNewGlobal return value has to be properly wrapped Reviewed-by: lagergren, hannesw ! src/jdk/nashorn/api/scripting/ScriptObjectMirror.java ! src/jdk/nashorn/internal/runtime/Context.java + test/script/basic/JDK-8015945.js + test/script/basic/JDK-8015945.js.EXPECTED Changeset: c6c05f23bca4 Author: sundar Date: 2013-06-05 13:33 +0530 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/c6c05f23bca4 Merge - src/jdk/nashorn/internal/objects/DateParser.java Changeset: 0feca8a93cb3 Author: attila Date: 2013-06-05 10:44 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/0feca8a93cb3 8015955: ObjectNode.elements should be stronger typed Reviewed-by: lagergren, sundar ! src/jdk/nashorn/internal/codegen/CodeGenerator.java ! src/jdk/nashorn/internal/ir/BlockLexicalContext.java ! src/jdk/nashorn/internal/ir/ObjectNode.java ! src/jdk/nashorn/internal/parser/JSONParser.java ! src/jdk/nashorn/internal/parser/Parser.java ! src/jdk/nashorn/internal/runtime/JSONFunctions.java Changeset: 9374c04f38fe Author: attila Date: 2013-06-05 12:17 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/9374c04f38fe 8015961: Several small code-gardening fixes Reviewed-by: lagergren, sundar ! src/jdk/nashorn/internal/codegen/Lower.java ! src/jdk/nashorn/internal/codegen/RuntimeCallSite.java ! src/jdk/nashorn/internal/ir/FunctionNode.java ! src/jdk/nashorn/internal/objects/GenericPropertyDescriptor.java ! src/jdk/nashorn/internal/objects/NativeMath.java ! src/jdk/nashorn/internal/runtime/Context.java ! src/jdk/nashorn/internal/runtime/ListAdapter.java ! src/jdk/nashorn/internal/runtime/regexp/joni/Parser.java Changeset: 60bc560df392 Author: hannesw Date: 2013-06-05 12:44 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/60bc560df392 8015350: Array.prototype.reduceRight issue with large length and index Reviewed-by: attila, sundar, lagergren ! src/jdk/nashorn/internal/objects/NativeArray.java ! src/jdk/nashorn/internal/runtime/arrays/ArrayIterator.java ! src/jdk/nashorn/internal/runtime/arrays/ArrayLikeIterator.java ! src/jdk/nashorn/internal/runtime/arrays/EmptyArrayLikeIterator.java ! src/jdk/nashorn/internal/runtime/arrays/IteratorAction.java ! src/jdk/nashorn/internal/runtime/arrays/MapIterator.java ! src/jdk/nashorn/internal/runtime/arrays/ReverseArrayIterator.java ! src/jdk/nashorn/internal/runtime/arrays/ReverseMapIterator.java + test/script/basic/JDK-8015350.js + test/script/basic/JDK-8015350.js.EXPECTED Changeset: 35bba63990b7 Author: jlaskey Date: 2013-06-05 10:32 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/35bba63990b7 8015911: $EXEC does not handle large outputs Reviewed-by: sundar, attila Contributed-by: james.laskey at oracle.com ! src/jdk/nashorn/internal/runtime/ScriptingFunctions.java Changeset: 16219bef66ec Author: jlaskey Date: 2013-06-05 12:41 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/16219bef66ec 8015910: Nashorn JavaFX includes are out of sync with JavaFX repo Reviewed-by: sundar Contributed-by: james.laskey at oracle.com ! src/jdk/nashorn/internal/runtime/resources/fx/controls.js ! src/jdk/nashorn/internal/runtime/resources/fx/graphics.js ! src/jdk/nashorn/internal/runtime/resources/fx/swt.js ! src/jdk/nashorn/internal/runtime/resources/fx/web.js Changeset: e3bd0ed64da8 Author: jlaskey Date: 2013-06-05 12:54 -0300 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/e3bd0ed64da8 Merge Changeset: d92b756bc739 Author: lana Date: 2013-06-10 17:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/d92b756bc739 Merge - src/jdk/nashorn/internal/objects/DateParser.java Changeset: dd371db92a91 Author: mduigou Date: 2013-06-18 10:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/nashorn/rev/dd371db92a91 Merge - .jcheck/conf From mike.duigou at oracle.com Tue Jun 18 21:05:16 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 19 Jun 2013 04:05:16 +0000 Subject: hg: lambda/lambda: 21 new changesets Message-ID: <20130619040518.E0FEB48308@hg.openjdk.java.net> Changeset: e247ee3924d5 Author: erikj Date: 2013-05-22 17:26 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/e247ee3924d5 8014514: Fix jvm args for sjavac Reviewed-by: tbell ! common/autoconf/basics.m4 ! common/autoconf/build-performance.m4 ! common/autoconf/generated-configure.sh Changeset: e7c09a983c3c Author: erikj Date: 2013-05-28 08:50 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/e7c09a983c3c 8007129: build-infra Add configure --with-jtreg option for location of JTREG Reviewed-by: tbell ! common/autoconf/basics.m4 ! common/autoconf/generated-configure.sh ! common/autoconf/spec.gmk.in ! common/autoconf/toolchain.m4 Changeset: 3a36c926a7aa Author: katleman Date: 2013-05-28 17:57 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/rev/3a36c926a7aa Merge Changeset: 46be9eb242d1 Author: katleman Date: 2013-05-30 10:57 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/rev/46be9eb242d1 Added tag jdk8-b92 for changeset 3a36c926a7aa ! .hgtags Changeset: 78852ce176db Author: jqzuo Date: 2013-05-28 20:03 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/78852ce176db 8014762: Add JMC configure option mapping to Jprt.gmk Summary: Need to add the mapping between JPRT env var and configure flag for JMC, from ALT_JMC_ZIP_DIR to --with-jmc-zip-dir (same pattern as for Javafx) Reviewed-by: tbell, erikj Contributed-by: klara.ward at oracle.com ! common/autoconf/generated-configure.sh ! common/makefiles/Jprt.gmk Changeset: c22d59e3f06e Author: pbhat Date: 2013-05-29 11:02 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/rev/c22d59e3f06e Merge Changeset: ea6f3bf82903 Author: jqzuo Date: 2013-06-04 00:12 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/rev/ea6f3bf82903 Merge ! common/autoconf/generated-configure.sh Changeset: 48c7e9fab688 Author: mduigou Date: 2013-06-05 13:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/rev/48c7e9fab688 Merge ! .hgtags - .jcheck/conf ! common/autoconf/generated-configure.sh Changeset: 33b6df33a2b7 Author: erikj Date: 2013-05-29 13:58 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/33b6df33a2b7 8013920: Configure sets JOBS to 0 if memory is too low. Reviewed-by: tbell ! common/autoconf/build-performance.m4 ! common/autoconf/generated-configure.sh Changeset: 03e60e87d92a Author: erikj Date: 2013-05-29 14:01 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/03e60e87d92a 8013489: New build system does not run codesign on SA-related launchers on OS X Reviewed-by: sla, tbell ! common/autoconf/basics.m4 ! common/autoconf/generated-configure.sh ! common/autoconf/spec.gmk.in ! common/makefiles/MakeBase.gmk ! common/makefiles/NativeCompilation.gmk Changeset: c31e9dc1fe3d Author: erikj Date: 2013-05-31 14:07 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/c31e9dc1fe3d 8014003: New build does not handle symlinks in workspace path Reviewed-by: tbell ! common/autoconf/basics.m4 ! common/autoconf/basics_windows.m4 ! common/autoconf/generated-configure.sh Changeset: 44259699e0b5 Author: erikj Date: 2013-06-04 10:23 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/44259699e0b5 8015784: Add configure parameter --with-update-version Reviewed-by: tbell, katleman, erikj Contributed-by: tristan.yan at oracle.com ! common/autoconf/generated-configure.sh ! common/autoconf/jdk-options.m4 Changeset: db3144e1f89b Author: mduigou Date: 2013-06-04 10:36 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/db3144e1f89b 8015510: (s) Improve JTReg location detection and provide location to test/Makefile Reviewed-by: erikj ! common/autoconf/generated-configure.sh ! common/autoconf/toolchain.m4 ! common/makefiles/Main.gmk Changeset: 9b8e8098172c Author: katleman Date: 2013-06-04 11:02 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/rev/9b8e8098172c Merge Changeset: f55734874c4f Author: katleman Date: 2013-06-04 15:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/rev/f55734874c4f Merge ! common/autoconf/generated-configure.sh Changeset: 27c51c6e31c1 Author: katleman Date: 2013-06-05 15:20 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/rev/27c51c6e31c1 6983966: remove lzma and upx from repository JDK8 Reviewed-by: tbell, paulk, ngthomas ! common/autoconf/generated-configure.sh ! common/makefiles/Jprt.gmk ! make/deploy-rules.gmk Changeset: 8dfb6ee04114 Author: katleman Date: 2013-06-06 09:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/rev/8dfb6ee04114 Added tag jdk8-b93 for changeset 27c51c6e31c1 ! .hgtags Changeset: 198d25db45da Author: erikj Date: 2013-06-11 13:08 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/198d25db45da 8008707: build-infra: Closed (deploy) can't be built using environment from SDK SetEnv.cmd Reviewed-by: tbell ! common/autoconf/generated-configure.sh ! common/autoconf/toolchain_windows.m4 Changeset: 3cbcc2b6ba41 Author: erikj Date: 2013-06-11 13:25 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/3cbcc2b6ba41 8010785: JDK 8 build on Linux fails with new build mechanism Reviewed-by: dholmes, tbell ! common/autoconf/generated-configure.sh ! common/autoconf/jdk-options.m4 Changeset: 50d2bde060f2 Author: erikj Date: 2013-06-12 10:33 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/rev/50d2bde060f2 Merge Changeset: 5faccb5b660e Author: mduigou Date: 2013-06-18 10:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/rev/5faccb5b660e Merge ! .hgtags - .jcheck/conf ! common/autoconf/generated-configure.sh ! common/makefiles/Main.gmk From mike.duigou at oracle.com Tue Jun 18 21:05:27 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 19 Jun 2013 04:05:27 +0000 Subject: hg: lambda/lambda/jdk: 83 new changesets Message-ID: <20130619042159.492204830C@hg.openjdk.java.net> Changeset: 583e6dec1ed7 Author: erikj Date: 2013-05-29 14:01 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/583e6dec1ed7 8013489: New build system does not run codesign on SA-related launchers on OS X Reviewed-by: sla, tbell ! makefiles/CompileLaunchers.gmk Changeset: d8c97d6772cd Author: erikj Date: 2013-05-30 09:29 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/d8c97d6772cd Merge Changeset: bc3a17982aae Author: erikj Date: 2013-05-31 14:05 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bc3a17982aae 7195481: FDS: debuginfo file for libjdwp.so is missed Reviewed-by: tbell ! make/jpda/back/Makefile ! makefiles/CompileNativeLibraries.gmk Changeset: c50add191a39 Author: katleman Date: 2013-06-04 11:03 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c50add191a39 Merge ! makefiles/CompileNativeLibraries.gmk Changeset: 16003f414ca3 Author: katleman Date: 2013-06-04 14:11 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/16003f414ca3 8015644: makefile changes to allow integration of new features Reviewed-by: tbell, erikj, dholmes Contributed-by: amy.y.wang at oracle.com ! makefiles/Images.gmk Changeset: 691d6c6cd332 Author: katleman Date: 2013-06-05 15:25 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/691d6c6cd332 6983966: remove lzma and upx from repository JDK8 Reviewed-by: tbell, paulk, ngthomas ! make/common/Defs-windows.gmk Changeset: 7b757d567346 Author: katleman Date: 2013-06-06 09:55 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/7b757d567346 Added tag jdk8-b93 for changeset 691d6c6cd332 ! .hgtags Changeset: fd377533608b Author: andrew Date: 2013-05-30 16:50 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/fd377533608b 8011693: Remove redundant fontconfig files Summary: Remove unused fontconfig files from OpenJDK GNU/Linux builds Reviewed-by: andrew, prr Contributed-by: Jiri Vanek ! make/sun/awt/Makefile ! makefiles/GendataFontConfig.gmk - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.Fedora.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.SuSE.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.Ubuntu.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.properties Changeset: b9b73bf450a4 Author: bae Date: 2013-05-31 14:30 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b9b73bf450a4 8015606: Text is not rendered correctly if destination buffer is custom Reviewed-by: prr, vadim ! src/share/classes/sun/java2d/loops/MaskFill.java + test/sun/java2d/loops/RenderToCustomBufferTest.java Changeset: 0a17344d074e Author: prr Date: 2013-05-31 09:25 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0a17344d074e 8015556: [macosx] surrogate pairs do not render properly. Reviewed-by: bae, jchen ! src/macosx/classes/sun/font/CCharToGlyphMapper.java + test/java/awt/FontClass/SurrogateTest/SuppCharTest.java Changeset: 3af3981dee11 Author: lana Date: 2013-06-05 09:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/3af3981dee11 Merge - test/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.sh Changeset: 768fcc36182a Author: anthony Date: 2013-05-30 18:10 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/768fcc36182a 8015303: [macosx] Application launched via custom URL Scheme does not receive URL Summary: Make copies of event parameters Reviewed-by: anthony, swingler, serb Contributed-by: James Tomson ! src/macosx/native/sun/osxapp/QueuingApplicationDelegate.m Changeset: 8472c148688c Author: ant Date: 2013-05-30 18:23 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8472c148688c 8013424: Regression: java.awt.datatransfer.FlavorListeners not notified on Linux/Java 7 Reviewed-by: anthony ! src/solaris/classes/sun/awt/X11/XClipboard.java Changeset: 56512cfccef9 Author: ant Date: 2013-05-30 18:31 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/56512cfccef9 8013773: requestFocusInWindow to a disabled component prevents window of getting focused Reviewed-by: leonidr, alexsch ! src/share/classes/java/awt/DefaultKeyboardFocusManager.java + test/java/awt/Focus/ResetMostRecentFocusOwnerTest/ResetMostRecentFocusOwnerTest.java Changeset: b0eab0f8b503 Author: anthony Date: 2013-05-31 14:12 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b0eab0f8b503 8013189: JMenuItems draw behind TextArea Summary: Untie XTextAreaPeer internal components from the TextArea parent to prevent its invalidation. I.e. force the java.awt.smartInvalidate=true locally. Reviewed-by: art, serb ! src/solaris/classes/sun/awt/X11/XTextAreaPeer.java + test/java/awt/TextArea/Mixing/TextAreaMixing.java Changeset: 481476e941fd Author: ant Date: 2013-05-31 15:56 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/481476e941fd 8015589: Test java/awt/Window/Grab/GrabTest.java fails on MacOSX Reviewed-by: anthony ! test/java/awt/Window/Grab/GrabTest.java Changeset: 611f8664c96c Author: malenkov Date: 2013-05-31 18:25 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/611f8664c96c 8013557: XMLEncoder in 1.7 can't encode objects initialized in no argument constructor Reviewed-by: alexsch ! src/share/classes/java/beans/XMLEncoder.java + test/java/beans/XMLEncoder/Test6989223.java + test/java/beans/XMLEncoder/Test7080156.java + test/java/beans/XMLEncoder/Test8013557.java Changeset: a4356b90f57d Author: vkarnauk Date: 2013-05-31 18:46 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a4356b90f57d 7068740: If you wrap a JTable in a JLayer you can't use the page up and page down cmds Reviewed-by: alexsch, alexp ! src/share/classes/javax/swing/plaf/basic/BasicTableUI.java + test/javax/swing/JTable/7068740/bug7068740.java Changeset: 791fd2ef87b3 Author: vkarnauk Date: 2013-05-31 19:34 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/791fd2ef87b3 6436314: Vector could be created with appropriate size in DefaultComboBoxModel Reviewed-by: alexsch, alexp ! src/share/classes/javax/swing/DefaultComboBoxModel.java Changeset: ae4683a6b860 Author: pchelko Date: 2013-06-03 10:14 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/ae4683a6b860 8015477: Support single threaded AWT/FX mode. Reviewed-by: ant, anthony ! src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java ! src/macosx/native/sun/awt/CDropTargetContextPeer.m ! src/macosx/native/sun/awt/LWCToolkit.m ! src/share/classes/java/awt/EventQueue.java ! src/share/classes/sun/awt/AWTAccessor.java + src/share/classes/sun/awt/FwDispatcher.java Changeset: 43f82f573c01 Author: alitvinov Date: 2013-06-03 14:05 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/43f82f573c01 7151823: The test incorrectly recognizing OS Reviewed-by: serb, alexp ! test/javax/swing/JTabbedPane/4624207/bug4624207.java Changeset: d378104e52e3 Author: anthony Date: 2013-06-03 16:27 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/d378104e52e3 8015500: Prevent sending multiple WINDOW_CLOSED events for already disposed windows Reviewed-by: anthony, serb Contributed-by: Jose Luis Martin ! src/share/classes/java/awt/Window.java + test/java/awt/Window/WindowClosedEvents/WindowClosedEventOnDispose.java Changeset: 9a8e0140123a Author: alitvinov Date: 2013-06-03 16:37 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/9a8e0140123a 6337518: Null Arrow Button Throws Exception in BasicComboBoxUI Reviewed-by: alexp, alexsch ! src/share/classes/javax/swing/plaf/basic/BasicComboBoxUI.java + test/javax/swing/JComboBox/6337518/bug6337518.java Changeset: 8b274eccd94a Author: mcherkas Date: 2013-06-05 14:21 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8b274eccd94a 8015375: Edits to text components hang for clipboard access Reviewed-by: art, anthony Contributed-by: Dmitry Markov ! src/solaris/native/sun/xawt/XlibWrapper.c Changeset: 1390369d4457 Author: vkarnauk Date: 2013-06-05 16:57 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/1390369d4457 8015425: [macosx] A follow-up for the fix 8010721 Reviewed-by: serb, anthony ! src/macosx/native/sun/awt/AWTWindow.m Changeset: a4af3d10d19e Author: ant Date: 2013-06-05 17:44 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a4af3d10d19e 8015339: Correct a wording in javadoc of java.awt.ContainerOrderFocusTraversalPolicy Reviewed-by: art, anthony ! src/share/classes/java/awt/ContainerOrderFocusTraversalPolicy.java Changeset: 6802f71a5eb2 Author: malenkov Date: 2013-06-05 18:15 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6802f71a5eb2 8013370: Null pointer exception when adding more than 9 accelators to a JMenuBar Reviewed-by: serb ! src/share/classes/javax/swing/KeyboardManager.java + test/javax/swing/KeyboardManager/8013370/Test8013370.java Changeset: e246bc03c8cb Author: lana Date: 2013-06-05 00:37 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e246bc03c8cb Merge - test/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.sh Changeset: 3e904a3f3c9f Author: lana Date: 2013-06-05 09:16 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/3e904a3f3c9f Merge Changeset: f272934d41fb Author: lana Date: 2013-06-05 12:30 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f272934d41fb Merge Changeset: 90df6756406f Author: sherman Date: 2013-05-29 19:50 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/90df6756406f 4759491: method ZipEntry.setTime(long) works incorrectly 6303183: Support NTFS and Unix-style timestamps for entries in Zip files 7012856: (zipfs) Newly created entry in zip file system should set all file times non-null values. 7012868: (zipfs) file times of entry in zipfs should always be the same regardless of TimeZone. Summary: to add suuport of Info-ZIP extended timestamp in extra data fields Reviewed-by: martin, alanb ! src/share/classes/java/util/zip/ZipConstants.java ! src/share/classes/java/util/zip/ZipEntry.java ! src/share/classes/java/util/zip/ZipFile.java ! src/share/classes/java/util/zip/ZipInputStream.java ! src/share/classes/java/util/zip/ZipOutputStream.java + src/share/classes/java/util/zip/ZipUtils.java ! src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystem.java ! src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipInfo.java ! test/demo/zipfs/ZipFSTester.java ! test/demo/zipfs/basic.sh ! test/java/util/jar/TestExtra.java ! test/java/util/zip/StoredCRC.java + test/java/util/zip/TestExtraTime.java ! test/java/util/zip/ZipFile/Assortment.java Changeset: 6df9b071b04d Author: jzavgren Date: 2013-05-30 12:19 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6df9b071b04d 8015299: Memory leak in jdk/src/solaris/bin/java_md_solinux.c Reviewed-by: martin, dholmes, chegar, ksrini ! src/solaris/bin/java_md_solinux.c Changeset: dc22b7241a70 Author: jbachorik Date: 2013-05-30 13:58 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/dc22b7241a70 8015627: test/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.java fails in agentvm mode Reviewed-by: alanb, chegar ! test/com/sun/jmx/remote/NotificationMarshalVersions/TestSerializationMismatch.java Changeset: 156ee44cd456 Author: psandoz Date: 2013-05-30 16:08 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/156ee44cd456 8014409: Spec typo: extra } in the spec for j.u.s.StreamBuilder Summary: Also fixes documentation on StreamBuilder.OfDouble Reviewed-by: alanb, chegar, mduigou ! src/share/classes/java/util/stream/StreamBuilder.java Changeset: b4742d038100 Author: psandoz Date: 2013-05-28 15:22 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b4742d038100 8014393: Minor typo in the spec for j.u.stream.Stream.findFirst() Reviewed-by: alanb, chegar ! src/share/classes/java/util/stream/DoubleStream.java ! src/share/classes/java/util/stream/IntStream.java ! src/share/classes/java/util/stream/LongStream.java ! src/share/classes/java/util/stream/Stream.java Changeset: b588955b7e5b Author: sherman Date: 2013-05-30 14:47 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b588955b7e5b 8015271: Conversion table for EUC-KR is incorrect Summary: to add the requested postal code mark character u+327e Reviewed-by: alanb ! make/tools/CharsetMapping/EUC_KR.map Changeset: 6407106f1b1c Author: xuelei Date: 2013-05-30 22:02 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6407106f1b1c 8014618: Need to strip leading zeros in TlsPremasterSecret of DHKeyAgreement Reviewed-by: xuelei Contributed-by: Pasi Eronen ! src/share/classes/com/sun/crypto/provider/DHKeyAgreement.java ! src/share/classes/sun/security/pkcs11/P11KeyAgreement.java ! src/share/classes/sun/security/pkcs11/P11Signature.java ! src/share/classes/sun/security/pkcs11/P11Util.java ! src/share/classes/sun/security/util/KeyUtil.java + test/com/sun/crypto/provider/TLS/TestLeadingZeroes.java + test/sun/security/pkcs11/tls/TestLeadingZeroesP11.java Changeset: 8402ef8fabde Author: ascarpino Date: 2013-05-30 22:19 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8402ef8fabde 7160837: DigestOutputStream does not turn off digest calculation when "close()" is called Reviewed-by: mullan, xuelei ! src/share/classes/java/security/DigestOutputStream.java ! src/share/classes/javax/crypto/CipherInputStream.java ! src/share/classes/javax/crypto/CipherOutputStream.java + test/javax/crypto/Cipher/CipherStreamClose.java Changeset: 6cb09d3cd309 Author: valeriep Date: 2013-05-29 20:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6cb09d3cd309 8013069: javax.crypto tests fail with new PBE algorithm names Summary: Shouldn't auto-generate default parameters for MAC objects. Reviewed-by: vinnie ! src/share/classes/com/sun/crypto/provider/HmacPKCS12PBESHA1.java ! src/share/classes/com/sun/crypto/provider/PBMAC1Core.java ! src/share/classes/com/sun/crypto/provider/SunJCE.java ! test/com/sun/crypto/provider/Mac/HmacPBESHA1.java ! test/com/sun/crypto/provider/Mac/MacClone.java Changeset: 918d9ac17740 Author: ascarpino Date: 2013-05-30 14:11 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/918d9ac17740 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException Reviewed-by: mullan ! src/share/classes/javax/crypto/Cipher.java ! src/share/classes/javax/crypto/CipherSpi.java Changeset: b47044426bcd Author: psandoz Date: 2013-05-31 09:58 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/b47044426bcd 8014732: Minor spec issue: java.util.Spliterator.getExactSizeIfKnown Summary: A minor documentation issue (not a spec issue). Reviewed-by: chegar, dl ! src/share/classes/java/util/Spliterator.java Changeset: dcf42861b5b1 Author: chegar Date: 2013-05-31 09:30 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/dcf42861b5b1 7107883: getNetworkPrefixLength() does not return correct prefix length Reviewed-by: alanb, michaelm ! src/solaris/native/java/net/NetworkInterface.c ! test/java/net/InterfaceAddress/NetworkPrefixLength.java Changeset: 243cd682c47b Author: alanb Date: 2013-05-31 12:17 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/243cd682c47b 8014854: (bf) CharBuffer.chars too slow with default implementation Reviewed-by: erikj, briangoetz, henryjen, psandoz, mduigou ! makefiles/CompileJavaClasses.gmk ! makefiles/GensrcBuffer.gmk ! src/share/classes/java/nio/Buffer.java ! src/share/classes/java/nio/ByteBufferAs-X-Buffer.java.template + src/share/classes/java/nio/CharBufferSpliterator.java ! src/share/classes/java/nio/Direct-X-Buffer.java.template ! src/share/classes/java/nio/Heap-X-Buffer.java.template ! src/share/classes/java/nio/StringCharBuffer.java ! src/share/classes/java/nio/X-Buffer.java.template + test/java/nio/Buffer/Chars.java Changeset: 933b1338b99c Author: naoto Date: 2013-05-31 11:20 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/933b1338b99c 7006052: awt_InputMethod.c cleanup is needed Reviewed-by: anthony ! src/solaris/native/sun/awt/awt_InputMethod.c Changeset: f522bbdf2859 Author: dxu Date: 2013-05-31 13:34 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f522bbdf2859 8015628: Test Failure in closed/java/io/pathNames/GeneralSolaris.java Reviewed-by: alanb ! test/java/io/pathNames/General.java ! test/java/io/pathNames/GeneralWin32.java Changeset: 11cdcf87ad5d Author: jzavgren Date: 2013-05-31 15:23 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/11cdcf87ad5d 8008972: Memory leak: Java_java_net_TwoStacksPlainDatagramSocketImpl_receive0 [parfait] Summary: Modified the code so that "jumbo frames" are truncated before buffer allocation is considered. This makes the buffer length a reliable indication that a buffer has been allocated, and it can then be used during clean up. Reviewed-by: chegar, khazra, alanb Contributed-by: john.zavgren at oracle.com ! src/windows/native/java/net/DualStackPlainDatagramSocketImpl.c ! src/windows/native/java/net/TwoStacksPlainDatagramSocketImpl.c Changeset: f6e6c27c19f3 Author: jzavgren Date: 2013-05-31 15:18 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f6e6c27c19f3 7188517: Check on '$' character is missing in the HttpCookie class constructor Summary: Modified the constructor code so that the cookie names are examined for leading dollar signs and if they do, an illegal argument exception is thrown. Reviewed-by: chegar, khazra, michaelm Contributed-by: john.zavgren at oracle.com ! src/share/classes/java/net/HttpCookie.java ! test/java/net/CookieHandler/TestHttpCookie.java Changeset: fc0b3e86fdcf Author: mduigou Date: 2013-05-31 11:06 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/fc0b3e86fdcf 8015686: {Int|Long}SummaryStatistics toString() throws IllegalFormatConversionException Reviewed-by: dholmes, alanb, psandoz ! src/share/classes/java/util/IntSummaryStatistics.java ! src/share/classes/java/util/LongSummaryStatistics.java Changeset: 198de8103df2 Author: mduigou Date: 2013-05-31 17:31 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/198de8103df2 Merge Changeset: c8410ce73ad6 Author: mduigou Date: 2013-02-12 17:04 -0800 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c8410ce73ad6 8007398: Peformance improvements to Integer and Long string formatting. Reviewed-by: mduigou, martin, darcy, briangoetz Contributed-by: Steven Schlansker , Mike Duigou ! src/share/classes/java/lang/Integer.java ! src/share/classes/java/lang/Long.java + test/java/lang/IntegralPrimitiveToString.java Changeset: f3c7c5f753dc Author: psandoz Date: 2013-06-03 10:28 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f3c7c5f753dc 8015008: Primitive iterator over empty sequence, null consumer: forEachRemaining methods do not throw NPE Reviewed-by: chegar ! src/share/classes/java/util/PrimitiveIterator.java + test/java/util/Iterator/PrimitiveIteratorDefaults.java Changeset: 44ef47f3efed Author: psandoz Date: 2013-06-03 10:45 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/44ef47f3efed 8014731: j.u.stream.StreamSupport class has default constructor generated Summary: This change set also fixes broken links Reviewed-by: alanb, chegar Contributed-by: Paul Sandoz , Henry Jen ! src/share/classes/java/util/stream/StreamSupport.java Changeset: 33d1376bf725 Author: nloodin Date: 2013-06-03 16:13 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/33d1376bf725 6526682: JConsole shows negative CPU Usage Reviewed-by: alanb, mchung ! src/share/classes/sun/tools/jconsole/SummaryTab.java Changeset: 3d4d7ed93731 Author: emc Date: 2013-06-03 10:44 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/3d4d7ed93731 8014834: shell tests don't begin with #!/bin/sh Summary: Some shell tests don't begin with the command interpreter line Reviewed-by: alanb, ksrini ! test/java/util/Locale/LocaleCategory.sh ! test/java/util/Locale/LocaleProviders.sh ! test/java/util/Locale/data/deflocale.sh ! test/java/util/PluggableLocale/BreakIteratorProviderTest.sh ! test/java/util/PluggableLocale/CalendarDataProviderTest.sh ! test/java/util/PluggableLocale/ClasspathTest.sh ! test/java/util/PluggableLocale/CollatorProviderTest.sh ! test/java/util/PluggableLocale/CurrencyNameProviderTest.sh ! test/java/util/PluggableLocale/DateFormatProviderTest.sh ! test/java/util/PluggableLocale/DateFormatSymbolsProviderTest.sh ! test/java/util/PluggableLocale/DecimalFormatSymbolsProviderTest.sh ! test/java/util/PluggableLocale/ExecTest.sh ! test/java/util/PluggableLocale/GenericTest.sh ! test/java/util/PluggableLocale/LocaleNameProviderTest.sh ! test/java/util/PluggableLocale/NumberFormatProviderTest.sh ! test/java/util/PluggableLocale/TimeZoneNameProviderTest.sh ! test/java/util/ResourceBundle/Bug6299235Test.sh ! test/sun/java2d/X11SurfaceData/SharedMemoryPixmapsTest/SharedMemoryPixmapsTest.sh ! test/sun/rmi/rmic/manifestClassPath/run.sh ! test/sun/rmi/rmic/newrmic/equivalence/batch.sh ! test/tools/launcher/MultipleJRE.sh Changeset: a79e2683eae3 Author: psandoz Date: 2013-06-03 17:37 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a79e2683eae3 8014383: StringJoiner example in class description not in sync with streams API Reviewed-by: alanb ! src/share/classes/java/util/StringJoiner.java Changeset: 62d3c82b4509 Author: shade Date: 2013-06-03 22:09 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/62d3c82b4509 8014966: Add the proper Javadoc to @Contended Summary: more extensive description. Reviewed-by: dholmes, mduigou, martin ! src/share/classes/sun/misc/Contended.java Changeset: f4e2a70260cf Author: ksrini Date: 2013-06-03 13:20 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f4e2a70260cf 8015813: add test/tools/pack200/TimeStamp.java to ProblemsList Reviewed-by: sherman ! test/ProblemList.txt Changeset: 1fd682e7110b Author: lana Date: 2013-06-03 16:09 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/1fd682e7110b Merge Changeset: 25cf25fb8c68 Author: sla Date: 2013-06-04 09:45 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/25cf25fb8c68 8015856: Remove java/lang/instrument/IsModifiableClassAgent.java from ProblemList.txt Reviewed-by: dholmes ! test/ProblemList.txt Changeset: 5223d3228658 Author: bchristi Date: 2013-06-04 10:04 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5223d3228658 8005698: Handle Frequent HashMap Collisions with Balanced Trees Summary: HashMap bins with many collisions store entries in balanced trees Reviewed-by: alanb, dl, mduigou ! src/share/classes/java/util/HashMap.java ! src/share/classes/java/util/Hashtable.java ! src/share/classes/java/util/LinkedHashMap.java ! src/share/classes/java/util/WeakHashMap.java ! src/share/classes/sun/misc/Hashing.java + test/java/util/Map/CheckRandomHashSeed.java ! test/java/util/Map/Collisions.java + test/java/util/Map/InPlaceOpsCollisions.java + test/java/util/Map/TreeBinSplitBackToEntries.java + test/java/util/Spliterator/SpliteratorCollisions.java Changeset: fad4ef2123ca Author: psandoz Date: 2013-06-04 11:53 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/fad4ef2123ca 8015790: Remove duplicate spliterator tests Reviewed-by: alanb, mduigou - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorLateBindingFailFastTest.java - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTraversingAndSplittingTest.java Changeset: f8b071428ca5 Author: michaelm Date: 2013-06-04 10:56 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f8b071428ca5 8014723: sun/misc/URLClassPath/ClassnameCharTest.java failing Reviewed-by: alanb, chegar ! src/share/classes/java/net/HttpURLPermission.java ! test/ProblemList.txt Changeset: 780fbbd50ce4 Author: alanb Date: 2013-06-04 11:52 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/780fbbd50ce4 8015872: ProblemList.txt updates (6/2013) Reviewed-by: chegar ! test/ProblemList.txt Changeset: 25a8e6fd0210 Author: alanb Date: 2013-06-04 15:18 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/25a8e6fd0210 8014855: TEST_BUG: java/nio/file/Files/StreamTest.java fails when sym links not supported Reviewed-by: alanb Contributed-by: henry.jen at oracle.com ! test/java/nio/file/Files/StreamTest.java Changeset: 379e1bcae693 Author: naoto Date: 2013-06-04 10:33 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/379e1bcae693 8013903: Japanese calendar field names are not displayed with -Djava.locale.providers=HOST on Windows Reviewed-by: okutsu ! src/share/classes/java/util/spi/LocaleServiceProvider.java ! src/share/classes/sun/util/locale/provider/FallbackLocaleProviderAdapter.java ! src/share/classes/sun/util/locale/provider/JRELocaleProviderAdapter.java ! src/share/classes/sun/util/locale/provider/LocaleProviderAdapter.java ! src/share/classes/sun/util/locale/provider/LocaleServiceProviderPool.java ! src/windows/classes/sun/util/locale/provider/HostLocaleProviderAdapterImpl.java ! test/java/util/Locale/LocaleProviders.java ! test/java/util/Locale/LocaleProviders.sh Changeset: d6401129327e Author: dl Date: 2013-06-04 21:59 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/d6401129327e 8005704: Update ConcurrentHashMap to v8 Reviewed-by: chegar, mduigou ! src/share/classes/java/util/concurrent/ConcurrentHashMap.java Changeset: bd84bad9ee99 Author: jdn Date: 2013-06-04 15:33 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bd84bad9ee99 8014097: add doPrivileged methods with limited privilege scope Reviewed-by: mchung ! src/share/classes/java/security/AccessControlContext.java ! src/share/classes/java/security/AccessController.java + test/java/security/AccessController/LimitedDoPrivileged.java Changeset: bb71021af586 Author: lana Date: 2013-06-04 21:37 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bb71021af586 Merge Changeset: 8a9f897a57d6 Author: alanb Date: 2013-06-05 11:12 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8a9f897a57d6 8003895: java/nio/channels/AsynchronousChannelGroup/Unbounded.java failing again [win64] Reviewed-by: chegar ! test/ProblemList.txt ! test/java/nio/channels/AsynchronousChannelGroup/Unbounded.java Changeset: de11b20f8c01 Author: psandoz Date: 2013-05-31 10:53 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/de11b20f8c01 8013649: HashMap spliterator tryAdvance() encounters remaining elements after forEachRemaining() Reviewed-by: chegar ! src/share/classes/java/util/HashMap.java ! src/share/classes/java/util/WeakHashMap.java ! test/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java Changeset: ae700bdb68b6 Author: alanb Date: 2013-06-05 13:57 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/ae700bdb68b6 8015880: GenerateBreakIteratorData build warning Reviewed-by: peytoia ! make/tools/src/build/tools/generatebreakiteratordata/CharSet.java Changeset: df1b35c7901d Author: dsamersoff Date: 2013-06-05 18:20 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/df1b35c7901d 8015604: JDP packets containing ideographic characters are broken Summary: Code uses string length rather than byte array length and non ascii entry brakes packet. Reviewed-by: dholmes, jbachorik, sla ! src/share/classes/sun/management/jdp/JdpPacketWriter.java ! test/sun/management/jdp/JdpUnitTest.java Changeset: 5edcc8ca4146 Author: chegar Date: 2013-06-05 16:06 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5edcc8ca4146 8011719: Properties.loadFromXML fails with a chunked HTTP connection Reviewed-by: michaelm ! src/share/classes/sun/net/www/protocol/http/HttpURLConnection.java + test/sun/net/www/protocol/http/HttpStreams.java Changeset: c1af6b5a979a Author: chegar Date: 2013-06-05 16:23 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c1af6b5a979a 8015963: Add at since tags to new ConcurrentHashMap methods Reviewed-by: shade, martin ! src/share/classes/java/util/concurrent/ConcurrentHashMap.java Changeset: e857b2a3ecee Author: fparain Date: 2013-06-05 08:41 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e857b2a3ecee 7150256: Add back Diagnostic Command JMX API Reviewed-by: mchung, jbachorik ! make/java/management/Exportedfiles.gmk ! make/java/management/FILES_c.gmk ! make/java/management/mapfile-vers ! makefiles/mapfiles/libmanagement/mapfile-vers + src/share/classes/com/sun/management/DiagnosticCommandMBean.java ! src/share/classes/java/lang/management/ManagementFactory.java + src/share/classes/sun/management/DiagnosticCommandArgumentInfo.java + src/share/classes/sun/management/DiagnosticCommandImpl.java + src/share/classes/sun/management/DiagnosticCommandInfo.java ! src/share/classes/sun/management/ManagementFactoryHelper.java ! src/share/classes/sun/management/VMManagement.java ! src/share/classes/sun/management/VMManagementImpl.java ! src/share/javavm/export/jmm.h + src/share/native/sun/management/DiagnosticCommandImpl.c ! src/share/native/sun/management/VMManagementImpl.c + test/com/sun/management/DiagnosticCommandMBean/DcmdMBeanDoubleInvocationTest.java + test/com/sun/management/DiagnosticCommandMBean/DcmdMBeanInvocationTest.java + test/com/sun/management/DiagnosticCommandMBean/DcmdMBeanPermissionsTest.java + test/com/sun/management/DiagnosticCommandMBean/DcmdMBeanTest.java ! test/java/lang/management/MXBean/MXBeanBehavior.java ! test/java/lang/management/ManagementFactory/MBeanServerMXBeanUnsupportedTest.java Changeset: 388b4d4cae3b Author: lana Date: 2013-06-05 12:31 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/388b4d4cae3b Merge - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorLateBindingFailFastTest.java - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTraversingAndSplittingTest.java Changeset: 080449feeca9 Author: lana Date: 2013-06-10 17:03 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/080449feeca9 Merge - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.Fedora.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.SuSE.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.Ubuntu.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.properties - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorLateBindingFailFastTest.java - test/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTraversingAndSplittingTest.java Changeset: e833fa13dce3 Author: erikj Date: 2013-06-11 13:26 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/e833fa13dce3 8010785: JDK 8 build on Linux fails with new build mechanism Reviewed-by: dholmes, tbell ! makefiles/CompileNativeLibraries.gmk ! makefiles/CreateJars.gmk ! makefiles/Import.gmk ! makefiles/Setup.gmk Changeset: 51479fa56b7c Author: erikj Date: 2013-06-12 10:33 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/51479fa56b7c Merge Changeset: c7bf11a30ae8 Author: mduigou Date: 2013-06-18 10:55 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c7bf11a30ae8 Merge ! .hgtags - .jcheck/conf ! makefiles/Setup.gmk ! src/share/classes/java/lang/Integer.java ! src/share/classes/java/lang/Long.java ! src/share/classes/java/util/HashMap.java ! src/share/classes/java/util/Hashtable.java ! src/share/classes/java/util/IntSummaryStatistics.java ! src/share/classes/java/util/LinkedHashMap.java ! src/share/classes/java/util/LongSummaryStatistics.java ! src/share/classes/java/util/PrimitiveIterator.java ! src/share/classes/java/util/Spliterator.java ! src/share/classes/java/util/StringJoiner.java ! src/share/classes/java/util/WeakHashMap.java ! src/share/classes/java/util/concurrent/ConcurrentHashMap.java ! src/share/classes/java/util/stream/DoubleStream.java ! src/share/classes/java/util/stream/IntStream.java ! src/share/classes/java/util/stream/LongStream.java ! src/share/classes/java/util/stream/Stream.java ! src/share/classes/java/util/stream/StreamBuilder.java ! src/share/classes/java/util/stream/StreamSupport.java ! src/share/classes/java/util/zip/ZipFile.java ! src/share/classes/sun/misc/Hashing.java ! test/ProblemList.txt ! test/java/nio/file/Files/StreamTest.java - test/java/util/Comparators/BasicTest.java ! test/java/util/Iterator/PrimitiveIteratorDefaults.java ! test/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java Changeset: 5f43607a73af Author: mduigou Date: 2013-06-18 20:03 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5f43607a73af handle null old values in compute ! src/share/classes/java/util/HashMap.java Changeset: 92d60e4c1a3c Author: mduigou Date: 2013-06-18 20:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/92d60e4c1a3c Nicer default replaceAll using forEach ! src/share/classes/java/util/concurrent/ConcurrentMap.java Changeset: 158d5a9be3cc Author: mduigou Date: 2013-06-18 20:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/158d5a9be3cc Merge ! src/share/classes/java/util/stream/DoubleStream.java ! src/share/classes/java/util/stream/IntStream.java ! src/share/classes/java/util/stream/LongStream.java ! src/share/classes/java/util/stream/Stream.java - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.Fedora.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.SuSE.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.Ubuntu.properties - src/solaris/classes/sun/awt/fontconfigs/linux.fontconfig.properties From henry.jen at oracle.com Tue Jun 18 23:17:02 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Wed, 19 Jun 2013 06:17:02 +0000 Subject: hg: lambda/lambda/jdk: Minor cleanup Message-ID: <20130619061751.8398148315@hg.openjdk.java.net> Changeset: 5a99a544f2ea Author: henryjen Date: 2013-06-18 23:16 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5a99a544f2ea Minor cleanup ! src/share/classes/java/util/stream/Streams.java From paul.sandoz at oracle.com Wed Jun 19 01:50:49 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Wed, 19 Jun 2013 08:50:49 +0000 Subject: hg: lambda/lambda/jdk: Add license. Message-ID: <20130619085146.4E7954831A@hg.openjdk.java.net> Changeset: 3fb2239353ea Author: psandoz Date: 2013-06-19 10:50 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/3fb2239353ea Add license. ! test/java/util/stream/test/org/openjdk/tests/java/util/regex/PatternTest.java From david.holmes at oracle.com Wed Jun 19 02:03:48 2013 From: david.holmes at oracle.com (David Holmes) Date: Wed, 19 Jun 2013 19:03:48 +1000 Subject: Question reg. holding Locks during invocation of Lambdas In-Reply-To: References: Message-ID: <51C173F4.4070006@oracle.com> Hi Gernot, On 18/06/2013 7:11 PM, Gernot Neppert wrote: > Hi all, > > I noticed that ConcurrentHashMap.computeIfAbsent() invokes the > user-supplied callback while being in a synchronized block. > > One of the rules I stick to in programming is "Don't invoke a user-supplied > callback from a library while holding a Lock". > (because it can lead to nasty deadlocks). > > If I understand it correctly, the purpose of computeIfAbsent() is delaying > the invocation of a possibly lengthy factory-expression until it has been > determined that a mapping for the key is not already present. > > Thus, shouldn't the callback better be called outside any held Locks? The contract for computeIfAbsent requires atomicity and a compute-at-most-once guarantee, hence the locking is needed. The compute function should be simple and self-contained to minimise potential for interactions that might lead to deadlocks, as per the docs: * The entire * method invocation is performed atomically, so the function is * applied at most once per key. Some attempted update operations * on this map by other threads may be blocked while computation * is in progress, so the computation should be short and simple, * and must not attempt to update any other mappings of this map. Sensible compute functions are unlikely to lead to deadlocks. David ----- > For those interested in more details: > A while back I wrote a class "CacheMap" that serves as a > drop-in-replacement for java.util.Map. Its get(Object key) method invokes a > uses-supplied callback if a mapping is not already present. > In the implementation I went to great lengths to ensure that no Locks are > held while invoking the callback while at the same time guaranteeing > consistency in a multi-threaded scenario. > (The Map-wide Lock is only held for a short duration to atomically check > for the key and put a temporary "factory" object in the internal Map. This > factory object then uses wait/notify to ensure that subsequent threads > requiring the same key will block until the callback has been invoked). > So I know it's possible to do it "correctly". Now I'd be reluctant to > replace my "CacheMap" with JDK's "ConcurrentHashMap" because of the > possible deadlocks waiting to happen. > From tom.hawtin at oracle.com Wed Jun 19 06:52:28 2013 From: tom.hawtin at oracle.com (Tom Hawtin) Date: Wed, 19 Jun 2013 14:52:28 +0100 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BB8AA1.3080208@oracle.com> <51BBBBAA.3090400@oracle.com> <51BF3B2A.3000806@oracle.com> <51C0E16F.60105@oracle.com> Message-ID: <51C1B79C.1030906@oracle.com> On 19/06/2013 00:40, John Rose wrote: > On Jun 18, 2013, at 3:38 PM, Tom Hawtin > wrote: >> return >> a==b ? 0 : >> a==null ? (nullsFirst ? -1 : 1) : >> real.compare(a, b); > > [...] It's also wrong. :) Tom From paul.sandoz at oracle.com Wed Jun 19 08:33:07 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Wed, 19 Jun 2013 17:33:07 +0200 Subject: IncompatibleClassChangeError example In-Reply-To: <51C00C5A.1030509@gmail.com> References: <51B49E27.7090300@gmail.com> <51C00C5A.1030509@gmail.com> Message-ID: <77428E43-F90A-42B0-9390-005971D1E149@oracle.com> Hi Peter. Replace "this.get()" with just "get()" or "Value.this.get()" and it runs OK, but i am not even sure it is entirely correct looking at the diffs of javap output of not this vs. this. e.g. public vs. private static interface for the method lambda$0. When using "this.get()" the following method is generated by javac: private static java.lang.Object lambda$0(java.util.function.Function); flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC Code: stack=2, locals=1, args_size=1 0: aload_0 1: aload_0 2: invokeinterface #4, 1 // InterfaceMethod get:()Ljava/lang/Object; 7: invokeinterface #5, 2 // InterfaceMethod java/util/function/Function.apply:(Ljava/lang/Object;)Ljava/lang/Object; 12: areturn LineNumberTable: line 1: 0 line 9: 2 To my untrained eye that looks dodgy with the two aload_0 instructions, it's trying to invoked the Value.get method on the Function interface. I would expect the method to have two args. Paul. 16c16 < #36 invokeinterface Test$Value.lambda$0:(Ljava/util/function/Function;)Ljava/lang/Object; --- > #36 invokestatic Test$Value.lambda$0:(Ljava/util/function/Function;)Ljava/lang/Object; 23c23 < #2 = InvokeDynamic #0:#38 // #0:lambda$:(LTest$Value;Ljava/util/function/Function;)Ljava/util/function/Supplier; --- > #2 = InvokeDynamic #0:#38 // #0:lambda$:(Ljava/util/function/Function;)Ljava/util/function/Supplier; 57c57 < #36 = MethodHandle #9:#49 // invokeinterface Test$Value.lambda$0:(Ljava/util/function/Function;)Ljava/lang/Object; --- > #36 = MethodHandle #6:#49 // invokestatic Test$Value.lambda$0:(Ljava/util/function/Function;)Ljava/lang/Object; 59c59 < #38 = NameAndType #51:#52 // lambda$:(LTest$Value;Ljava/util/function/Function;)Ljava/util/function/Supplier; --- > #38 = NameAndType #51:#52 // lambda$:(Ljava/util/function/Function;)Ljava/util/function/Supplier; 73c73 < #52 = Utf8 (LTest$Value;Ljava/util/function/Function;)Ljava/util/function/Supplier; --- > #52 = Utf8 (Ljava/util/function/Function;)Ljava/util/function/Supplier; 95c95 < stack=4, locals=2, args_size=2 --- > stack=3, locals=2, args_size=2 98,102c98,101 < 4: aload_0 < 5: aload_1 < 6: invokedynamic #2, 0 // InvokeDynamic #0:lambda$:(LTest$Value;Ljava/util/function/Function;)Ljava/util/function/Supplier; < 11: invokespecial #3 // Method Test$SuppliedValue."":(Ljava/util/function/Supplier;)V < 14: areturn --- > 4: aload_1 > 5: invokedynamic #2, 0 // InvokeDynamic #0:lambda$:(Ljava/util/function/Function;)Ljava/util/function/Supplier; > 10: invokespecial #3 // Method Test$SuppliedValue."":(Ljava/util/function/Supplier;)V > 13: areturn 107,108c106,107 < 0 15 0 this LTest$Value; < 0 15 1 mapper Ljava/util/function/Function; --- > 0 14 0 this LTest$Value; > 0 14 1 mapper Ljava/util/function/Function; 111,112c110,111 < 0 15 0 this LTest$Value; < 0 15 1 mapper Ljava/util/function/Function<-TT;+TR;>; --- > 0 14 0 this LTest$Value; > 0 14 1 mapper Ljava/util/function/Function<-TT;+TR;>; 115,116c114,115 < public java.lang.Object lambda$0(java.util.function.Function); < flags: ACC_PUBLIC, ACC_SYNTHETIC --- > private static java.lang.Object lambda$0(java.util.function.Function); > flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC 118,119c117,118 < stack=2, locals=2, args_size=2 < 0: aload_1 --- > stack=2, locals=1, args_size=1 > 0: aload_0 127,132d125 < LocalVariableTable: < Start Length Slot Name Signature < 0 13 0 this LTest$Value; < LocalVariableTypeTable: < Start Length Slot Name Signature < 0 13 0 this LTest$Value; On Jun 18, 2013, at 9:29 AM, Peter Levart wrote: > Just a reminder that the following problem is still present... > > Regards, Peter > > On 06/09/2013 05:24 PM, Peter Levart wrote: >> Hi, >> >> When I compile and run the following program with the latest tip of >> lambda repo: >> >> >> import java.util.function.Function; >> import java.util.function.Supplier; >> >> public class ICCEBug { >> >> interface Value extends Supplier { >> default Value map(Function >> mapper) { >> return new SuppliedValue<>(() -> mapper.apply(this.get())); >> } >> } >> >> static class SuppliedValue implements Value { >> private final Supplier supplier; >> >> SuppliedValue(Supplier supplier) { >> this.supplier = supplier; >> } >> >> @Override >> public T get() { >> return supplier.get(); >> } >> } >> >> public static void main(String[] args) { >> Value name = () -> "Peter"; >> Value sentence = name.map(nm -> "Hello " + nm + "!"); >> System.out.println(sentence.get()); >> } >> } >> >> >> >> ... I get the following exception: >> >> Exception in thread "main" java.lang.IncompatibleClassChangeError: >> Class ICCEBug$$Lambda$2 does not implement the requested interface >> ICCEBug$Value >> at ICCEBug$Value.lambda$0(ICCEBug.java:17) >> at ICCEBug$Value$$Lambda$3.get(Unknown Source) >> at ICCEBug$SuppliedValue.get(ICCEBug.java:30) >> at ICCEBug.main(ICCEBug.java:37) >> >> >> >> It looks like something is not compiled correctly. >> >> Regards, Peter >> > > From mike.duigou at oracle.com Wed Jun 19 09:59:45 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Wed, 19 Jun 2013 16:59:45 +0000 Subject: hg: lambda/lambda/jdk: 2 new changesets Message-ID: <20130619170052.C245448334@hg.openjdk.java.net> Changeset: 58404716ee27 Author: mduigou Date: 2013-06-19 09:56 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/58404716ee27 manual merge of 8016446 ! src/share/classes/java/util/AbstractMap.java ! src/share/classes/java/util/HashMap.java ! src/share/classes/java/util/Hashtable.java ! src/share/classes/java/util/IdentityHashMap.java ! src/share/classes/java/util/LinkedHashMap.java ! src/share/classes/java/util/Map.java ! src/share/classes/java/util/TreeMap.java ! src/share/classes/java/util/WeakHashMap.java ! src/share/classes/java/util/concurrent/ConcurrentMap.java ! test/java/util/Map/Defaults.java Changeset: bda67586a839 Author: mduigou Date: 2013-06-19 09:59 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bda67586a839 Merge From henry.jen at oracle.com Wed Jun 19 10:29:54 2013 From: henry.jen at oracle.com (Henry Jen) Date: Wed, 19 Jun 2013 10:29:54 -0700 Subject: RFR (2nd round) 8009736: Comparator API cleanup In-Reply-To: <51BCF8B6.4050307@oracle.com> References: <51B790E6.6020209@oracle.com> <51BCF8B6.4050307@oracle.com> Message-ID: <51C1EA92.9010102@oracle.com> A ping to wake up the thread, there is a minor update regard the use of @apiNote since last email. Thanks in advance for reviewing. Cheers, Henry On 06/15/2013 04:28 PM, Henry Jen wrote: > Reflecting feedbacks received so far, please see > > http://cr.openjdk.java.net/~henryjen/ccc/8009736.3/webrev/ > http://cr.openjdk.java.net/~henryjen/ccc/8009736.3/specdiff > > Cheers, > Henry > > > On 06/11/2013 02:04 PM, Henry Jen wrote: >> Hi, >> >> Please review http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/webrev/ >> >> Highlight of changes, >> >> - Comparators class is now only package-private implementations. The >> public static methods have been move to other arguably more appropriate >> places, mostly in Comparator. >> >> - Comparator.reverseOrder() is renamed to Comparator.reversed() >> >> - nullsFirst(Comparator) and nullsLast(Comparator) are introduced to >> wrap up a comparator to be null-friendly. >> >> To see the API changes, found the specdiff at >> http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/specdiff/overview-summary.html >> >> Cheers, >> Henry >> > From henry.jen at oracle.com Wed Jun 19 10:54:06 2013 From: henry.jen at oracle.com (Henry Jen) Date: Wed, 19 Jun 2013 10:54:06 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BB8AA1.3080208@oracle.com> <51BBBBAA.3090400@oracle.com> <51BF3B2A.3000806@oracle.com> <51C0E16F.60105@oracle.com> Message-ID: <51C1F03E.8030905@oracle.com> On Jun 18, 2013, at 3:38 PM, Tom Hawtin wrote: > > On 17/06/2013 19:37, Henry Jen wrote: > >> I am not sure what do you mean by API serial proxy, my understanding of the concern is that we want to hide the implementation detail from serialization. Seems to me, that is the same as we distill the implementation to it's essential minimum. Isn't it? For this case, it would be a boolean and the original Comparator, and that's the latest implementation. > > A serial proxy is a class that which the serialisation mechanism works > on to work out what to write into the stream, but isn't the actual > working class. When serialised the working class returns a serial proxy > from its writeReplace, which is actually serialised. When deserialised > the serial proxy replaces itself with a working class from readResolve. > > So for example, if we find out HotSpot works better if we have two > different implementations for returning sign +1 and -1 (because that > determines where the calling code immediately jumps to), then we can do > that with three classes, one of which being a serial proxy with the > original implementation name and fields. Similarly if we found that the > target comparator was almost always the same type and wanted to combine > the comparators when used in sequence, we could have a serial proxy > handle that. > Thanks, in this case, as the class is so simple and we are not likely to have a new/different implementation after we finish it. I guess it is good enough. > > Also as this class considers all null to be a single value, I think that > should be nullFirst instead of nullsFirst. > >From another perspective, the dataset to be compared could have more than one null, thus nullsFirst. EG had looked at those names and CCC is going on, so I think we will stay with this. Cheers, Henry From forax at univ-mlv.fr Wed Jun 19 11:09:40 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Wed, 19 Jun 2013 20:09:40 +0200 Subject: IncompatibleClassChangeError example In-Reply-To: <77428E43-F90A-42B0-9390-005971D1E149@oracle.com> References: <51B49E27.7090300@gmail.com> <51C00C5A.1030509@gmail.com> <77428E43-F90A-42B0-9390-005971D1E149@oracle.com> Message-ID: <51C1F3E4.6070205@univ-mlv.fr> On 06/19/2013 05:33 PM, Paul Sandoz wrote: > Hi Peter. > > Replace "this.get()" with just "get()" or "Value.this.get()" and it runs OK, but i am not even sure it is entirely correct looking at the diffs of javap output of not this vs. this. > > e.g. public vs. private static interface for the method lambda$0. > > > When using "this.get()" the following method is generated by javac: > > private static java.lang.Object lambda$0(java.util.function.Function); > flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC > Code: > stack=2, locals=1, args_size=1 > 0: aload_0 > 1: aload_0 > 2: invokeinterface #4, 1 // InterfaceMethod get:()Ljava/lang/Object; > 7: invokeinterface #5, 2 // InterfaceMethod java/util/function/Function.apply:(Ljava/lang/Object;)Ljava/lang/Object; > 12: areturn > LineNumberTable: > line 1: 0 > line 9: 2 > > To my untrained eye that looks dodgy with the two aload_0 instructions, it's trying to invoked the Value.get method on the Function interface. I would expect the method to have two args. > > Paul. yes, more precisely, lambda$0 should have only one parameter (the Function) and the method should not be static (so 'this' is available), So javac has trouble with 'this' inside a default method of an interface. R?mi > > 16c16 > < #36 invokeinterface Test$Value.lambda$0:(Ljava/util/function/Function;)Ljava/lang/Object; > --- >> #36 invokestatic Test$Value.lambda$0:(Ljava/util/function/Function;)Ljava/lang/Object; > 23c23 > < #2 = InvokeDynamic #0:#38 // #0:lambda$:(LTest$Value;Ljava/util/function/Function;)Ljava/util/function/Supplier; > --- >> #2 = InvokeDynamic #0:#38 // #0:lambda$:(Ljava/util/function/Function;)Ljava/util/function/Supplier; > 57c57 > < #36 = MethodHandle #9:#49 // invokeinterface Test$Value.lambda$0:(Ljava/util/function/Function;)Ljava/lang/Object; > --- >> #36 = MethodHandle #6:#49 // invokestatic Test$Value.lambda$0:(Ljava/util/function/Function;)Ljava/lang/Object; > 59c59 > < #38 = NameAndType #51:#52 // lambda$:(LTest$Value;Ljava/util/function/Function;)Ljava/util/function/Supplier; > --- >> #38 = NameAndType #51:#52 // lambda$:(Ljava/util/function/Function;)Ljava/util/function/Supplier; > 73c73 > < #52 = Utf8 (LTest$Value;Ljava/util/function/Function;)Ljava/util/function/Supplier; > --- >> #52 = Utf8 (Ljava/util/function/Function;)Ljava/util/function/Supplier; > 95c95 > < stack=4, locals=2, args_size=2 > --- >> stack=3, locals=2, args_size=2 > 98,102c98,101 > < 4: aload_0 > < 5: aload_1 > < 6: invokedynamic #2, 0 // InvokeDynamic #0:lambda$:(LTest$Value;Ljava/util/function/Function;)Ljava/util/function/Supplier; > < 11: invokespecial #3 // Method Test$SuppliedValue."":(Ljava/util/function/Supplier;)V > < 14: areturn > --- >> 4: aload_1 >> 5: invokedynamic #2, 0 // InvokeDynamic #0:lambda$:(Ljava/util/function/Function;)Ljava/util/function/Supplier; >> 10: invokespecial #3 // Method Test$SuppliedValue."":(Ljava/util/function/Supplier;)V >> 13: areturn > 107,108c106,107 > < 0 15 0 this LTest$Value; > < 0 15 1 mapper Ljava/util/function/Function; > --- >> 0 14 0 this LTest$Value; >> 0 14 1 mapper Ljava/util/function/Function; > 111,112c110,111 > < 0 15 0 this LTest$Value; > < 0 15 1 mapper Ljava/util/function/Function<-TT;+TR;>; > --- >> 0 14 0 this LTest$Value; >> 0 14 1 mapper Ljava/util/function/Function<-TT;+TR;>; > 115,116c114,115 > < public java.lang.Object lambda$0(java.util.function.Function); > < flags: ACC_PUBLIC, ACC_SYNTHETIC > --- >> private static java.lang.Object lambda$0(java.util.function.Function); >> flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC > 118,119c117,118 > < stack=2, locals=2, args_size=2 > < 0: aload_1 > --- >> stack=2, locals=1, args_size=1 >> 0: aload_0 > 127,132d125 > < LocalVariableTable: > < Start Length Slot Name Signature > < 0 13 0 this LTest$Value; > < LocalVariableTypeTable: > < Start Length Slot Name Signature > < 0 13 0 this LTest$Value; > > > > On Jun 18, 2013, at 9:29 AM, Peter Levart wrote: > >> Just a reminder that the following problem is still present... >> >> Regards, Peter >> >> On 06/09/2013 05:24 PM, Peter Levart wrote: >>> Hi, >>> >>> When I compile and run the following program with the latest tip of >>> lambda repo: >>> >>> >>> import java.util.function.Function; >>> import java.util.function.Supplier; >>> >>> public class ICCEBug { >>> >>> interface Value extends Supplier { >>> default Value map(Function >>> mapper) { >>> return new SuppliedValue<>(() -> mapper.apply(this.get())); >>> } >>> } >>> >>> static class SuppliedValue implements Value { >>> private final Supplier supplier; >>> >>> SuppliedValue(Supplier supplier) { >>> this.supplier = supplier; >>> } >>> >>> @Override >>> public T get() { >>> return supplier.get(); >>> } >>> } >>> >>> public static void main(String[] args) { >>> Value name = () -> "Peter"; >>> Value sentence = name.map(nm -> "Hello " + nm + "!"); >>> System.out.println(sentence.get()); >>> } >>> } >>> >>> >>> >>> ... I get the following exception: >>> >>> Exception in thread "main" java.lang.IncompatibleClassChangeError: >>> Class ICCEBug$$Lambda$2 does not implement the requested interface >>> ICCEBug$Value >>> at ICCEBug$Value.lambda$0(ICCEBug.java:17) >>> at ICCEBug$Value$$Lambda$3.get(Unknown Source) >>> at ICCEBug$SuppliedValue.get(ICCEBug.java:30) >>> at ICCEBug.main(ICCEBug.java:37) >>> >>> >>> >>> It looks like something is not compiled correctly. >>> >>> Regards, Peter >>> >> > From john.r.rose at oracle.com Wed Jun 19 16:28:11 2013 From: john.r.rose at oracle.com (John Rose) Date: Wed, 19 Jun 2013 16:28:11 -0700 Subject: RFR 8009736: Comparator API cleanup In-Reply-To: <51C1B79C.1030906@oracle.com> References: <51B790E6.6020209@oracle.com> <0CE8FB8C-E4A6-44C0-B845-8603601ED75B@oracle.com> <398D4E28-9160-45BA-AFE0-C07B768A1AD8@Oracle.com> <55A1615D-1543-4E58-8DF1-10F31EC607F3@oracle.com> <51BA0153.8010409@oracle.com> <1DB7B5C8-F40B-4901-915D-A14B46F5F52E@oracle.com> <51BB8AA1.3080208@oracle.com> <51BBBBAA.3090400@oracle.com> <51BF3B2A.3000806@oracle.com> <51C0E16F.60105@oracle.com> <51C1B79C.1030906@oracle.com> Message-ID: <92E1F00D-40E2-4AEE-80BF-26ADE29271DF@oracle.com> On Jun 19, 2013, at 6:52 AM, Tom Hawtin wrote: > It's also wrong. :) That too, but it may produce the wrong answer fractionally slower than without the first line. :-) From david.katleman at oracle.com Wed Jun 19 19:20:15 2013 From: david.katleman at oracle.com (David Katleman) Date: Wed, 19 Jun 2013 19:20:15 -0700 Subject: jdk8-lambda builds failing in hotspot for all platforms ( thread.hpp ) Message-ID: <51C266DF.3090800@oracle.com> All the jdk8-lambda nightly builds failed tonight, in hotspot, in thread.hpp https://jbs.oracle.com/bugs/browse/JDK-8017117 http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=8017117 Thanks Dave http://rehudson.us.oracle.com:8080/hudson/job/2-build-solaris-sparc/2106/console /localtools/solaris-sparc/SUNWspro/SS12u1/prod/bin/CC -DSOLARIS -DSPARC_WORKS -DSPARC -DPRODUCT -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/share/vm/prims -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/prims -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/share/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/precompiled -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/cpu/sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/cpu/sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os_cpu/solaris_sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/os/solaris/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os/solaris/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/os/posix/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os/posix/vm -I../generated -DHOTSPOT_RELEASE_VERSION="\"25.0-b34\"" -DHOTSPOT_BUILD_TARGET="\"product\"" -DHOTSPOT_BUILD_USER="\"\"" -DHOTSPOT_LIB_ARCH=\"sparc\" -DHOTSPOT_VM_DISTRO="\"Java HotSpot(TM)\"" -DTARGET_OS_FAMILY_solaris -DTARGET_ARCH_sparc -DTARGET_ARCH_MODEL_sparc -DTARGET_OS_ARCH_solaris_sparc -DTARGET_OS_ARCH_MODEL_solaris_sparc -DTARGET_COMPILER_sparcWorks -DCOMPILER2 -DCOMPILER1 -DDONT_USE_PRECOMPILED_HEADER -xmemalign=4s -m32 -xarch=sparc /HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os_cpu/solaris_sparc/vm/solaris_sparc.il -template=no%extdef -features=no%split_init -D_Crun_inline_placement -library=%none -KPIC -mt -xdebugformat=stabs -xO4 -g0 -xs -xwe -features=no%except -DINCLUDE_TRACE -DHAVE_DTRACE_H -DDTRACE_ENABLED -c -xMMD -xMF ../generated/dependencies/ad_sparc.o.d -o ad_sparc.o ../generated/adfiles/ad_sparc.cpp "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. 5 Error(s) detected. gmake[6]: *** [accessFlags.o] Error 5 gmake[6]: *** Waiting for unfinished jobs.... "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. 5 Error(s) detected. gmake[6]: *** [abstractCompiler.o] Error 5 "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. 5 Error(s) detected. gmake[6]: *** [ad_sparc.o] Error 5 gmake[6]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/solaris_sparc_compiler2/product' gmake[5]: *** [the_vm] Error 2 gmake[5]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/solaris_sparc_compiler2/product' gmake[4]: *** [product] Error 2 gmake[4]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot' gmake[3]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/make' gmake[3]: *** [generic_build2] Error 2 gmake[2]: *** [product] Error 2 gmake[2]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/make' gmake[1]: *** [/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/_hotspot.timestamp] Error 2 gmake[1]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/common/makefiles' gmake: *** [hotspot-only] Error 2 Archiving artifacts Recording test results Notifying upstream projects of job completion Finished: FAILURE From mike.duigou at oracle.com Wed Jun 19 20:18:58 2013 From: mike.duigou at oracle.com (Mike Duigou) Date: Wed, 19 Jun 2013 20:18:58 -0700 Subject: jdk8-lambda builds failing in hotspot for all platforms ( thread.hpp ) In-Reply-To: <51C266DF.3090800@oracle.com> References: <51C266DF.3090800@oracle.com> Message-ID: <6E35DDDE-3CA7-444B-8996-8154FE46EA77@oracle.com> I have pushed a sync of jdk8 b94 to lambda/hotspot. This should resolve the issue. Mike On Jun 19 2013, at 19:20 , David Katleman wrote: > All the jdk8-lambda nightly builds failed tonight, in hotspot, in thread.hpp > > https://jbs.oracle.com/bugs/browse/JDK-8017117 > http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=8017117 > > Thanks > Dave > > http://rehudson.us.oracle.com:8080/hudson/job/2-build-solaris-sparc/2106/console > /localtools/solaris-sparc/SUNWspro/SS12u1/prod/bin/CC -DSOLARIS -DSPARC_WORKS -DSPARC -DPRODUCT -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/share/vm/prims -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/prims -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/share/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/precompiled -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/cpu/sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/cpu/sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os_cpu/solaris_sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/os/solaris/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os/solaris/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/os/posix/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os/posix/vm -I../generated -DHOTSPOT_RELEASE_VERSION="\"25.0-b34\"" -DHOTSPOT_BUILD_TARGET="\"product\"" -DHOTSPOT_BUILD_USER="\"\"" -DHOTSPOT_LIB_ARCH=\"sparc\" -DHOTSPOT_VM_DISTRO="\"Java HotSpot(TM)\"" -DTARGET_OS_FAMILY_solaris -DTARGET_ARCH_sparc -DTARGET_ARCH_MODEL_sparc -DTARGET_OS_ARCH_solaris_sparc -DTARGET_OS_ARCH_MODEL_solaris_sparc -DTARGET_COMPILER_sparcWorks -DCOMPILER2 -DCOMPILER1 -DDONT_USE_PRECOMPILED_HEADER -xmemalign=4s -m32 -xarch=sparc /HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os_cpu/solaris_sparc/vm/solaris_sparc.il -template=no%extdef -features=no%split_init -D_Crun_inline_placement -library=%none -KPIC -mt -xdebugformat=stabs -xO4 -g0 -xs -xwe -features=no%except -DINCLUDE_TRACE -DHAVE_DTRACE_H -DDTRACE_ENABLED -c -xMMD -xMF ../generated/dependencies/ad_sparc.o.d -o ad_sparc.o ../generated/adfiles/ad_sparc.cpp > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. > 5 Error(s) detected. > gmake[6]: *** [accessFlags.o] Error 5 > gmake[6]: *** Waiting for unfinished jobs.... > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. > 5 Error(s) detected. > gmake[6]: *** [abstractCompiler.o] Error 5 > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. > "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. > 5 Error(s) detected. > gmake[6]: *** [ad_sparc.o] Error 5 > gmake[6]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/solaris_sparc_compiler2/product' > gmake[5]: *** [the_vm] Error 2 > gmake[5]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/solaris_sparc_compiler2/product' > gmake[4]: *** [product] Error 2 > gmake[4]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot' > gmake[3]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/make' > gmake[3]: *** [generic_build2] Error 2 > gmake[2]: *** [product] Error 2 > gmake[2]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/make' > gmake[1]: *** [/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/_hotspot.timestamp] Error 2 > gmake[1]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/common/makefiles' > gmake: *** [hotspot-only] Error 2 > Archiving artifacts > Recording test results > Notifying upstream projects of job completion > Finished: FAILURE From david.katleman at oracle.com Wed Jun 19 20:37:56 2013 From: david.katleman at oracle.com (David Katleman) Date: Wed, 19 Jun 2013 20:37:56 -0700 Subject: jdk8-lambda builds failing in hotspot for all platforms ( thread.hpp ) In-Reply-To: <6E35DDDE-3CA7-444B-8996-8154FE46EA77@oracle.com> References: <51C266DF.3090800@oracle.com> <6E35DDDE-3CA7-444B-8996-8154FE46EA77@oracle.com> Message-ID: <51C27914.1090605@oracle.com> On 6/19/2013 8:18 PM, Mike Duigou wrote: > I have pushed a sync of jdk8 b94 to lambda/hotspot. > > This should resolve the issue. Thanks Mike, I've started another build Dave On Jun 19 2013, at 19:20 , David Katleman wrote: >> All the jdk8-lambda nightly builds failed tonight, in hotspot, in thread.hpp >> >> https://jbs.oracle.com/bugs/browse/JDK-8017117 >> http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=8017117 >> >> Thanks >> Dave >> >> http://rehudson.us.oracle.com:8080/hudson/job/2-build-solaris-sparc/2106/console >> /localtools/solaris-sparc/SUNWspro/SS12u1/prod/bin/CC -DSOLARIS -DSPARC_WORKS -DSPARC -DPRODUCT -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/share/vm/prims -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/prims -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/share/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/precompiled -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/cpu/sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/cpu/sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os_cpu/solaris_sparc/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/os/solaris/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os/solaris/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/closed/os/posix/vm -I/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os/posix/vm -I../generated -DHOTSPOT_RELEASE_VERSION="\"25.0-b34\"" -DHOTSPOT_BUILD_TARGET="\"product\"" -DHOTSPOT_BUILD_USER="\"\"" -DHOTSPOT_LIB_ARCH=\"sparc\" -DHOTSPOT_VM_DISTRO="\"Java HotSpot(TM)\"" -DTARGET_OS_FAMILY_solaris -DTARGET_ARCH_sparc -DTARGET_ARCH_MODEL_sparc -DTARGET_OS_ARCH_solaris_sparc -DTARGET_OS_ARCH_MODEL_solaris_sparc -DTARGET_COMPILER_sparcWorks -DCOMPILER2 -DCOMPILER1 -DDONT_USE_PRECOMPILED_HEADER -xmemalign=4s -m32 -xarch=sparc /HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/os_cpu/solaris_sparc/vm/solaris_sparc.il -template=no%extdef -features=no%split_init -D_Crun_inline_placement -library=%none -KPIC -mt -xdebugformat=stabs -xO4 -g0 -xs -xwe -features=no%except -DINCLUDE_TRACE -DHAVE_DTRACE_H -DDTRACE_ENABLED -c -xMMD -xMF ../generated/dependencies/ad_sparc.o.d -o ad_sparc.o ../generated/adfiles/ad_sparc.cpp >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. >> 5 Error(s) detected. >> gmake[6]: *** [accessFlags.o] Error 5 >> gmake[6]: *** Waiting for unfinished jobs.... >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. >> 5 Error(s) detected. >> gmake[6]: *** [abstractCompiler.o] Error 5 >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 261: Error: Type name expected instead of "TRACE_BUFFER". >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Type name expected instead of "TRACE_BUFFER". >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 452: Error: Use ";" to terminate declarations. >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: Use ";" to terminate declarations. >> "/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/src/share/vm/runtime/thread.hpp", line 453: Error: TRACE_BUFFER is not defined. >> 5 Error(s) detected. >> gmake[6]: *** [ad_sparc.o] Error 5 >> gmake[6]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/solaris_sparc_compiler2/product' >> gmake[5]: *** [the_vm] Error 2 >> gmake[5]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/solaris_sparc_compiler2/product' >> gmake[4]: *** [product] Error 2 >> gmake[4]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot' >> gmake[3]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/make' >> gmake[3]: *** [generic_build2] Error 2 >> gmake[2]: *** [product] Error 2 >> gmake[2]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/hotspot/make' >> gmake[1]: *** [/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/build/solaris-sparc/hotspot/_hotspot.timestamp] Error 2 >> gmake[1]: Leaving directory `/HUDSON2/workspace/2-build-solaris-sparc/jdk8-lambda/4843/common/makefiles' >> gmake: *** [hotspot-only] Error 2 >> Archiving artifacts >> Recording test results >> Notifying upstream projects of job completion >> Finished: FAILURE From mike.duigou at oracle.com Wed Jun 19 20:16:36 2013 From: mike.duigou at oracle.com (mike.duigou at oracle.com) Date: Thu, 20 Jun 2013 03:16:36 +0000 Subject: hg: lambda/lambda/hotspot: 65 new changesets Message-ID: <20130620031844.02E4048352@hg.openjdk.java.net> Changeset: 61dcf187a198 Author: katleman Date: 2013-06-06 09:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/61dcf187a198 Added tag jdk8-b93 for changeset 573d86d412cd ! .hgtags Changeset: 194b27b865bc Author: amurillo Date: 2013-05-24 09:35 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/194b27b865bc 8015305: new hotspot build - hs25-b35 Reviewed-by: jcoomes ! make/hotspot_version Changeset: ccdecfece956 Author: bharadwaj Date: 2013-05-21 16:17 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/ccdecfece956 8014059: JSR292: Failed to reject invalid class cplmhl00201m28n Summary: Restrict reference of interface methods by invokestatic and invokespecial to classfile version 52 or later. Reviewed-by: kvn, hseigel ! src/share/vm/classfile/classFileParser.cpp Changeset: f54c85acc043 Author: mikael Date: 2013-05-21 09:43 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/f54c85acc043 8013726: runtime/memory/ReserveMemory.java fails due to 'assert(bytes % os::vm_allocation_granularity() == 0) failed: reserve block size' Summary: Fix regression test to work on all platforms Reviewed-by: ctornqvi, dholmes ! src/share/vm/prims/whitebox.cpp ! test/runtime/memory/ReserveMemory.java ! test/testlibrary/whitebox/sun/hotspot/WhiteBox.java Changeset: 1a07e086ff28 Author: dholmes Date: 2013-05-21 19:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/1a07e086ff28 Merge Changeset: 6bd680e9ea35 Author: coleenp Date: 2013-05-22 14:37 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror Summary: Inject protection_domain, signers, init_lock into java_lang_Class Reviewed-by: stefank, dholmes, sla ! agent/src/share/classes/sun/jvm/hotspot/memory/DictionaryEntry.java ! agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java ! agent/src/share/classes/sun/jvm/hotspot/utilities/HeapGXLWriter.java ! agent/src/share/classes/sun/jvm/hotspot/utilities/HeapHprofBinWriter.java ! agent/src/share/classes/sun/jvm/hotspot/utilities/soql/JSJavaInstanceKlass.java ! src/share/vm/classfile/classFileParser.cpp ! src/share/vm/classfile/javaClasses.cpp ! src/share/vm/classfile/javaClasses.hpp ! src/share/vm/classfile/vmSymbols.hpp ! src/share/vm/oops/arrayKlass.cpp ! src/share/vm/oops/instanceKlass.cpp ! src/share/vm/oops/instanceKlass.hpp ! src/share/vm/oops/klass.cpp ! src/share/vm/oops/klass.hpp ! src/share/vm/oops/objArrayKlass.hpp ! src/share/vm/oops/typeArrayKlass.hpp ! src/share/vm/prims/jvm.cpp ! src/share/vm/runtime/vmStructs.cpp Changeset: 699d9df07e59 Author: ctornqvi Date: 2013-05-23 17:39 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/699d9df07e59 8009576: Test returns ClassNotFoundException Summary: Small classpath fix and move tests into open Reviewed-by: mgerdin, zgu + test/runtime/Metaspace/FragmentMetaspace.java + test/runtime/Metaspace/FragmentMetaspaceSimple.java + test/runtime/Metaspace/classes/test/Empty.java + test/runtime/testlibrary/GeneratedClassLoader.java Changeset: b7fa10a3a69a Author: sspitsyn Date: 2013-05-23 23:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes Summary: The fix of perf regression is to use method_idnum() for direct indexing into NMT Reviewed-by: twisti, kvn, coleenp, dholmes Contributed-by: serguei.spitsyn at oracle.com ! src/share/vm/oops/instanceKlass.cpp ! src/share/vm/oops/instanceKlass.hpp ! src/share/vm/prims/methodHandles.cpp ! src/share/vm/prims/methodHandles.hpp Changeset: cd83e1d98347 Author: dcubed Date: 2013-05-24 10:21 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/cd83e1d98347 Merge Changeset: 6c138b9851fb Author: sspitsyn Date: 2013-05-24 17:36 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock Summary: The "delete mnt" needs to grab MemberNameTable_lock if !SafepointSynchronize::is_at_safepoint() Reviewed-by: sla, mgerdin, dholmes, jmasa Contributed-by: serguei.spitsyn at oracle.com ! src/share/vm/oops/instanceKlass.cpp Changeset: 3970971c91e0 Author: shade Date: 2013-05-27 12:49 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/3970971c91e0 8015270: @Contended: fix multiple issues in the layout code Summary: field count handling fixed, has_nonstatic_fields invariant fixed, oop map overrun fixed; new asserts Reviewed-by: kvn, dcubed, coleenp ! src/share/vm/classfile/classFileParser.cpp + test/runtime/contended/HasNonStatic.java + test/runtime/contended/OopMaps.java Changeset: a213d425d87a Author: ctornqvi Date: 2013-05-28 15:08 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/a213d425d87a 8015329: Print reason for failed MiniDumpWriteDump() call Summary: Printing both result from GetLastError and text representation of error. Also changed so that we produce dumps by default on client versions of Windows when running with a debug build. Also reviewed by peter.allwin at oracle.com Reviewed-by: sla, dholmes ! src/os/windows/vm/os_windows.cpp Changeset: 51af5fae397d Author: ccheung Date: 2013-05-24 17:19 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/51af5fae397d 8015265: revise the fix for 8007037 Reviewed-by: sspitsyn, dholmes, dcubed ! src/share/vm/oops/constantPool.cpp Changeset: 4cc7d4d5dc92 Author: zgu Date: 2013-05-28 08:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/4cc7d4d5dc92 Merge Changeset: 01c2bdd24bb5 Author: shade Date: 2013-05-28 19:54 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/01c2bdd24bb5 8015493: runtime/contended/OopMaps.java fails with OutOfMemory Summary: limit the memory footprint to dodge OutOfMemory errors. Reviewed-by: dcubed, ctornqvi, iignatyev ! test/runtime/contended/OopMaps.java Changeset: 9ea643afcaaf Author: dcubed Date: 2013-05-28 11:35 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/9ea643afcaaf Merge Changeset: dcb062bea05b Author: jprovino Date: 2013-05-28 11:17 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/dcb062bea05b 8013461: There is a symbol AsyncGetCallTrace in libjvm.symbols that does not exist in minimal/libjvm.a when DEBUG_LEVEL == release Summary: AsyncGetCallTrace is needed in libjvm.symbols so that programs which reference it can build correctly. Reviewed-by: dholmes, bobv ! make/excludeSrc.make ! src/share/vm/prims/forte.cpp Changeset: fb14e9ed1594 Author: jprovino Date: 2013-05-28 11:32 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/fb14e9ed1594 8011064: Some tests have failed with SIGSEGV on arm-hflt on build b82 Summary: NMT_detail is only supported when frame pointers are not omitted (-fno-omit-frame-pointer). Reviewed-by: dholmes, cjplummer ! src/share/vm/services/memTracker.cpp ! src/share/vm/utilities/globalDefinitions.hpp Changeset: 9e954e8d9139 Author: jprovino Date: 2013-05-28 15:24 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/9e954e8d9139 Merge Changeset: 9e86c5544295 Author: jiangli Date: 2013-05-30 13:19 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/9e86c5544295 Merge Changeset: 0def34ab1c98 Author: tamao Date: 2013-05-21 16:43 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/0def34ab1c98 8015007: Incorrect print format in error message for VM cannot allocate the requested heap Summary: Correct the wrong print format in error message for VM cannot allocate the requested heap; and clean up the error message call in check_alignment() Reviewed-by: brutisso, tschatzl Contributed-by: tamao ! src/share/vm/memory/universe.cpp Changeset: 14d3f71f831d Author: tamao Date: 2013-05-22 11:11 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/14d3f71f831d 8007762: Rename a bunch of methods in size policy across collectors Summary: Rename: compute_generations_free_space() = compute_eden_space_size() + compute_old_gen_free_space(); update related logging messages Reviewed-by: jmasa, johnc, tschatzl, brutisso Contributed-by: tamao ! src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp ! src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp ! src/share/vm/gc_implementation/parNew/asParNewGeneration.cpp ! src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp ! src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp ! src/share/vm/gc_implementation/parallelScavenge/psGCAdaptivePolicyCounters.hpp ! src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp ! src/share/vm/gc_implementation/shared/adaptiveSizePolicy.cpp Changeset: 0886b99a4d1b Author: jwilhelm Date: 2013-05-24 14:16 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/0886b99a4d1b Merge Changeset: eda078b01c65 Author: stefank Date: 2013-05-27 15:22 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/eda078b01c65 8015268: NPG: 2.5% regression in young GC times on CRM Sales Opty Summary: Split SystemDictionary and ClassLoaderDataGraph root processing to help load balancing. Reviewed-by: tschatzl, johnc ! src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp ! src/share/vm/gc_implementation/parallelScavenge/pcTasks.hpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp ! src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp ! src/share/vm/gc_implementation/parallelScavenge/psTasks.cpp ! src/share/vm/gc_implementation/parallelScavenge/psTasks.hpp ! src/share/vm/memory/sharedHeap.cpp Changeset: 95c00927be11 Author: stefank Date: 2013-05-27 12:56 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/95c00927be11 8015428: Remove unused CDS support from StringTable Summary: The string in StringTable is not used by CDS anymore. Remove the unnecessary code in preparation for 8015422: Large performance hit when the StringTable is walked twice in Parallel Scavenge Reviewed-by: pliden, tschatzl, coleenp ! src/share/vm/classfile/symbolTable.cpp Changeset: 8dbc025ff709 Author: stefank Date: 2013-05-27 12:58 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/8dbc025ff709 8015422: Large performance hit when the StringTable is walked twice in Parallel Scavenge Summary: Combine the calls to StringTable::unlink and StringTable::oops_do in Parallel Scavenge. Reviewed-by: pliden, coleenp ! src/share/vm/classfile/symbolTable.cpp ! src/share/vm/classfile/symbolTable.hpp ! src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Changeset: f41a577cffb0 Author: jwilhelm Date: 2013-05-31 09:55 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/f41a577cffb0 Merge Changeset: b786c04b7be1 Author: amurillo Date: 2013-05-31 09:37 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/b786c04b7be1 Merge Changeset: 5a028ee56116 Author: amurillo Date: 2013-05-31 09:37 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/5a028ee56116 Added tag hs25-b35 for changeset b786c04b7be1 ! .hgtags Changeset: b7569f617285 Author: amurillo Date: 2013-05-31 10:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/b7569f617285 8015690: new hotspot build - hs25-b36 Reviewed-by: jcoomes ! make/hotspot_version Changeset: 5534bd30c151 Author: jcoomes Date: 2013-05-30 13:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/5534bd30c151 6725714: par compact - add a table to speed up bitmap searches Reviewed-by: jmasa, tschatzl ! src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Changeset: 47bdfb3d010f Author: stefank Date: 2013-05-30 10:58 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/47bdfb3d010f 8015486: PSScavenge::is_obj_in_young is unnecessarily slow with UseCompressedOops Summary: Compare compressed oops to a compressed young gen boundary instead of uncompressing the oops before doing the young gen boundary check. Reviewed-by: brutisso, jmasa ! src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp ! src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp ! src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp ! src/share/vm/gc_implementation/parallelScavenge/psScavenge.inline.hpp Changeset: c20186fa611b Author: jwilhelm Date: 2013-06-01 10:00 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/c20186fa611b Merge Changeset: e72f7eecc96d Author: tschatzl Date: 2013-05-28 09:32 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/e72f7eecc96d 8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen Summary: Fixed the output of G1SummarizeRSetStats: too small datatype for the number of concurrently processed cards, added concurrent remembered set thread time retrieval for Linux and Windows (BSD uses os::elapsedTime() now), and other cleanup. The information presented during VM operation is now relative to the previous output, not always cumulative if G1SummarizeRSetStatsPeriod > 0. At VM exit, the code prints a cumulative summary. Reviewed-by: johnc, jwilhelm ! make/excludeSrc.make ! src/os/bsd/vm/os_bsd.cpp ! src/os/linux/vm/os_linux.cpp ! src/os/windows/vm/os_windows.cpp ! src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp ! src/share/vm/gc_implementation/g1/concurrentG1Refine.hpp ! src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp ! src/share/vm/gc_implementation/g1/g1RemSet.cpp ! src/share/vm/gc_implementation/g1/g1RemSet.hpp + src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp + src/share/vm/gc_implementation/g1/g1RemSetSummary.hpp + test/gc/g1/TestSummarizeRSetStats.java Changeset: 3a4805ad0005 Author: johnc Date: 2013-06-04 10:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/3a4805ad0005 8015244: G1: Verification after a full GC is incorrectly placed. Summary: In a full GC, move the verification after the GC to after RSet rebuilding. Verify RSet entries during a full GC under control of a flag. Reviewed-by: tschatzl, brutisso ! src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp ! src/share/vm/gc_implementation/g1/g1RemSet.cpp ! src/share/vm/gc_implementation/g1/g1_globals.hpp ! src/share/vm/gc_implementation/g1/heapRegion.cpp Changeset: 87c64c0438fb Author: tamao Date: 2013-06-03 14:37 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/87c64c0438fb 6976350: G1: deal with fragmentation while copying objects during GC Summary: Create G1ParGCAllocBufferContainer to contain two buffers instead of previously using one buffer, in order to hold the first priority buffer longer. Thus, when some large objects hits the value of free space left in the first priority buffer it has an alternative to fit in the second priority buffer while the first priority buffer is given more chances to try allocating smaller objects. Overall, it will improve heap space efficiency. Reviewed-by: johnc, jmasa, brutisso Contributed-by: tamao ! src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp ! src/share/vm/gc_implementation/shared/parGCAllocBuffer.hpp Changeset: 2f7a31318b84 Author: johnc Date: 2013-06-04 14:00 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/2f7a31318b84 Merge Changeset: a1ebd310d5c1 Author: iklam Date: 2013-05-28 16:36 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG Summary: Added dumping of object sizes in CDS archive, sorted by MetaspaceObj::Type Reviewed-by: coleenp, acorn ! src/share/vm/memory/allocation.cpp ! src/share/vm/memory/allocation.hpp ! src/share/vm/memory/metaspace.cpp ! src/share/vm/memory/metaspace.hpp ! src/share/vm/memory/metaspaceShared.cpp ! src/share/vm/oops/annotations.cpp ! src/share/vm/oops/constMethod.cpp ! src/share/vm/oops/constantPool.cpp ! src/share/vm/oops/cpCache.cpp ! src/share/vm/oops/klass.cpp ! src/share/vm/oops/method.cpp ! src/share/vm/oops/methodCounters.cpp ! src/share/vm/oops/methodData.cpp ! src/share/vm/oops/symbol.cpp ! src/share/vm/utilities/array.hpp Changeset: fe00365c8f31 Author: sspitsyn Date: 2013-05-30 11:46 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/fe00365c8f31 8015436: compiler/ciReplay/TestSA.sh fails with assert() index is out of bounds Summary: The InstanceKlass _initial_method_idnum value must be adjusted if overpass methods are added. Reviewed-by: twisti, kvn Contributed-by: serguei.spitsyn at oracle.com ! src/share/vm/classfile/defaultMethods.cpp + test/compiler/8015436/Test8015436.java Changeset: a589c78a8811 Author: rbackman Date: 2013-05-31 13:02 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/a589c78a8811 8014709: Constructor.getAnnotatedReturnType() returns empty AnnotatedType Reviewed-by: stefank, rbackman Contributed-by: Joel Borggren-Franck ! src/share/vm/runtime/reflection.cpp ! test/runtime/8007320/ConstMethodTest.java Changeset: efe8b7d64424 Author: ctornqvi Date: 2013-05-31 20:24 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/efe8b7d64424 6726963: multi_allocate() call does not CHECK_NULL and causes crash in fastdebug bits Summary: Using CHECK_NULL when calling multi_allocate() from the corresponding reflection code; added test for this condition Reviewed-by: dholmes, minqi Contributed-by: Mikhailo Seledtsov ! src/share/vm/runtime/reflection.cpp + test/runtime/memory/MultiAllocateNullCheck.java Changeset: 532c55335fb6 Author: dcubed Date: 2013-06-01 09:28 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/532c55335fb6 Merge Changeset: 4552a7633a07 Author: hseigel Date: 2013-06-03 10:00 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/4552a7633a07 8015385: Remove RelaxAccessControlCheck for JDK 8 bytecodes Summary: Check bytecode versions along with RelaxAccessControlCheck version Reviewed-by: dholmes, acorn ! src/share/vm/classfile/verifier.hpp ! src/share/vm/runtime/reflection.cpp Changeset: e7d29a019a3c Author: sspitsyn Date: 2013-06-03 14:28 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/e7d29a019a3c 8014052: JSR292: assert(end_offset == next_offset) failed: matched ending Summary: A call to the finalize_operands_merge() must be unconditional Reviewed-by: kvn, twisti Contributed-by: serguei.spitsyn at oracle.com ! src/share/vm/prims/jvmtiRedefineClasses.cpp Changeset: 2f004f9dc9e1 Author: sspitsyn Date: 2013-06-04 01:06 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/2f004f9dc9e1 8015803: Test8015436.java fails 'can not access a member of class Test8015436 with modifiers "public static"' Summary: Newly added test has an issue: the main class must be public Reviewed-by: kvn, jbachorik, coleenp Contributed-by: serguei.spitsyn at oracle.com ! test/compiler/8015436/Test8015436.java Changeset: 04551f4dbdb9 Author: nloodin Date: 2013-06-05 09:47 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/04551f4dbdb9 Merge Changeset: 62e7bac9524f Author: dcubed Date: 2013-06-04 19:39 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/62e7bac9524f 8010257: remove unused thread-local variables _ScratchA and _ScratchB Summary: Remove dead code. Reviewed-by: twisti, coleenp ! src/share/vm/runtime/thread.hpp Changeset: 6bf8b8bb7c19 Author: hseigel Date: 2013-06-05 14:12 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/6bf8b8bb7c19 8009302: Mac OS X: JVM crash on infinite recursion on Appkit Thread Summary: Use SA_ONSTACK flag to ensure signal gets delivered properly. Reviewed-by: dholmes, coleenp Contributed-by: gerard.ziemski at oracle.com ! src/os/bsd/vm/os_bsd.cpp Changeset: f8c8cace25ad Author: dcubed Date: 2013-06-06 05:56 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/f8c8cace25ad Merge ! src/os/bsd/vm/os_bsd.cpp Changeset: 320b4e0f0892 Author: roland Date: 2013-05-30 11:21 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/320b4e0f0892 8015585: Missing regression test for 8011771 Summary: missing regression test Reviewed-by: kvn + test/compiler/8011771/Test8011771.java Changeset: f15fe46d8c00 Author: twisti Date: 2013-05-30 08:37 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/f15fe46d8c00 8015266: fix some -Wsign-compare warnings in adlc Reviewed-by: kvn ! src/share/vm/adlc/archDesc.cpp ! src/share/vm/adlc/dict2.cpp ! src/share/vm/adlc/formssel.cpp ! src/share/vm/adlc/formssel.hpp ! src/share/vm/adlc/output_c.cpp Changeset: 28e5aed7f3a6 Author: roland Date: 2013-05-31 14:40 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/28e5aed7f3a6 8009981: nashorn tests fail with -XX:+VerifyStack Summary: nmethod::preserve_callee_argument_oops() must take appendix into account. Reviewed-by: kvn, twisti ! src/share/vm/code/nmethod.cpp ! src/share/vm/runtime/deoptimization.cpp ! src/share/vm/runtime/frame.cpp ! src/share/vm/runtime/frame.hpp ! src/share/vm/runtime/sharedRuntime.cpp ! src/share/vm/runtime/sharedRuntime.hpp Changeset: 83dcb116fdb1 Author: kvn Date: 2013-05-31 13:54 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/83dcb116fdb1 8015441: runThese crashed with assert(opcode == Op_ConP || opcode == Op_ThreadLocal || opcode == Op_CastX2P ..) failed: sanity Summary: Relax the assert to accept any raw ptr types. Reviewed-by: roland ! src/share/vm/opto/escape.cpp Changeset: c07dd9be16e8 Author: anoll Date: 2013-05-31 06:41 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/c07dd9be16e8 8013496: Code cache management command line options work only in special order. Another order of arguments does not deliver the second parameter to the jvm. Summary: Moved check that ReservedCodeCacheSize >= InitialCodeCacheSize to Arguments::check_vm_args_consistency(). As a result, the ordering in which the two parameters are given to the VM is not relevant. Added a regression test. Reviewed-by: kvn, twisti ! src/share/vm/runtime/arguments.cpp + test/compiler/8013496/Test8013496.sh Changeset: 603ca7e51354 Author: roland Date: 2013-04-24 11:49 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/603ca7e51354 8010460: Interpreter on some platforms loads ConstMethod::_max_stack and misses extra stack slots for JSR 292 Summary: ConstMethod::max_stack() doesn't account for JSR 292 appendix. Reviewed-by: kvn ! src/cpu/sparc/vm/cppInterpreter_sparc.cpp ! src/cpu/sparc/vm/interp_masm_sparc.cpp ! src/cpu/sparc/vm/templateInterpreter_sparc.cpp ! src/cpu/x86/vm/cppInterpreter_x86.cpp ! src/cpu/x86/vm/templateInterpreter_x86_32.cpp ! src/cpu/x86/vm/templateInterpreter_x86_64.cpp ! src/share/vm/interpreter/bytecodeInterpreter.cpp ! src/share/vm/oops/method.hpp ! src/share/vm/opto/matcher.cpp Changeset: 813f26e34135 Author: anoll Date: 2013-06-03 08:52 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/813f26e34135 8013329: File leak in hotspot/src/share/vm/compiler/compileBroker.cpp Summary: Added calling of the destructor of CompileLog so that files are closed. Added/moved memory allocation/deallocation of the string that contains the name of the log file to class CompileLog. Reviewed-by: kvn, roland ! src/share/vm/compiler/compileBroker.cpp ! src/share/vm/compiler/compileLog.cpp ! src/share/vm/compiler/compileLog.hpp Changeset: b274ac1dbe11 Author: adlertz Date: 2013-06-03 12:39 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/b274ac1dbe11 8005956: C2: assert(!def_outside->member(r)) failed: Use of external LRG overlaps the same LRG defined in this block Summary: Disable re-materialization of reaching definitions (which have live inputs) for phi nodes when spilling. Reviewed-by: twisti, kvn ! src/share/vm/opto/reg_split.cpp Changeset: 770e91e578a6 Author: kvn Date: 2013-06-03 14:02 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/770e91e578a6 Merge Changeset: 075ea888b039 Author: morris Date: 2013-06-04 12:06 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/075ea888b039 8010724: [parfait] Null pointer dereference in hotspot/src/share/vm/c1/c1_LIRGenerator.cpp Summary: added guarantee() Reviewed-by: kvn ! src/share/vm/c1/c1_LIRGenerator.cpp Changeset: 2cb5d5f6d5e5 Author: simonis Date: 2013-06-04 22:16 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/2cb5d5f6d5e5 8015252: Enable HotSpot build with Clang Reviewed-by: twisti, dholmes, kvn ! make/bsd/makefiles/adlc.make ! make/bsd/makefiles/gcc.make ! make/bsd/makefiles/vm.make ! make/linux/makefiles/adlc.make ! make/linux/makefiles/gcc.make ! src/os/bsd/vm/os_bsd.cpp ! src/os_cpu/linux_x86/vm/linux_x86_32.s ! src/os_cpu/linux_x86/vm/os_linux_x86.cpp Changeset: 609aad72004a Author: anoll Date: 2013-06-06 09:29 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/609aad72004a 8014246: remove assert to catch access to object headers in index_oop_from_field_offset_long Reviewed-by: twisti, jrose ! src/share/vm/prims/unsafe.cpp Changeset: ef1818846c22 Author: kvn Date: 2013-06-06 11:02 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/ef1818846c22 Merge ! src/os/bsd/vm/os_bsd.cpp Changeset: 3c78a14da19d Author: amurillo Date: 2013-06-07 09:25 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/3c78a14da19d Merge ! .hgtags Changeset: 1beed1f6f9ed Author: amurillo Date: 2013-06-07 09:25 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/1beed1f6f9ed Added tag hs25-b36 for changeset 3c78a14da19d ! .hgtags Changeset: 3480d7ff09ec Author: mduigou Date: 2013-06-19 19:42 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/3480d7ff09ec Merge ! .hgtags - .jcheck/conf ! src/share/vm/classfile/classFileParser.cpp ! src/share/vm/classfile/defaultMethods.cpp ! src/share/vm/classfile/vmSymbols.hpp ! src/share/vm/oops/constMethod.cpp ! src/share/vm/oops/constantPool.cpp ! src/share/vm/oops/instanceKlass.cpp ! src/share/vm/oops/instanceKlass.hpp ! src/share/vm/oops/method.cpp ! src/share/vm/oops/method.hpp ! src/share/vm/prims/methodHandles.cpp ! src/share/vm/runtime/reflection.cpp From howard.lovatt at gmail.com Thu Jun 20 00:24:46 2013 From: howard.lovatt at gmail.com (Howard Lovatt) Date: Thu, 20 Jun 2013 17:24:46 +1000 Subject: RFR : 8013712 : (XS) Add Objects.nonNull and Objects.isNull In-Reply-To: <518524C1.5010203@CoSoCo.de> References: <5E833D21-CF16-4468-809E-5569964C85B8@oracle.com> <518524C1.5010203@CoSoCo.de> Message-ID: I would say not needed, !isNull() is sufficient. If included isNotNull() is the better name. On 5 May 2013 01:09, Ulf Zibis wrote: > > Am 04.05.2013 04:28, schrieb Mike Duigou: > > I have updated the webrev to include incorporate the feedback I have > received. > > > > http://cr.openjdk.java.net/~mduigou/JDK-8013712/1/webrev/ > > > > Regarding the naming of the "nonNull" method. I originally added this > method in 2011 but I've forgotten since then why it has the name it does. > As best as I can determine the name is either derived from the the name > used by Guava for the same predicate, "notNull", or the names derives from > the name "requireNonNull" in that this method doesn't require that the > reference be non-null. The EG hasn't been concerned that this method > doesn't use the "is" prefix. > > Do we need nonNull/isNotNull() at all, as it's always !isNull()? > Anyway I would prefer isNotNull(). > > -Ulf > > > -- -- Howard. From jack at moxley.co.uk Thu Jun 20 00:36:32 2013 From: jack at moxley.co.uk (Jack Moxley) Date: Thu, 20 Jun 2013 08:36:32 +0100 Subject: RFR : 8013712 : (XS) Add Objects.nonNull and Objects.isNull In-Reply-To: References: <5E833D21-CF16-4468-809E-5569964C85B8@oracle.com> <518524C1.5010203@CoSoCo.de> Message-ID: Really depends about whether you want the method to be bad English, or really bad English. :-). All this double negativity gets me down. What's wrong with exists() ? Sent from my iPhone On 20 Jun 2013, at 08:24, Howard Lovatt wrote: > I would say not needed, !isNull() is sufficient. If included isNotNull() is > the better name. > > > On 5 May 2013 01:09, Ulf Zibis wrote: > >> >> Am 04.05.2013 04:28, schrieb Mike Duigou: >>> I have updated the webrev to include incorporate the feedback I have >> received. >>> >>> http://cr.openjdk.java.net/~mduigou/JDK-8013712/1/webrev/ >>> >>> Regarding the naming of the "nonNull" method. I originally added this >> method in 2011 but I've forgotten since then why it has the name it does. >> As best as I can determine the name is either derived from the the name >> used by Guava for the same predicate, "notNull", or the names derives from >> the name "requireNonNull" in that this method doesn't require that the >> reference be non-null. The EG hasn't been concerned that this method >> doesn't use the "is" prefix. >> >> Do we need nonNull/isNotNull() at all, as it's always !isNull()? >> Anyway I would prefer isNotNull(). >> >> -Ulf > > > -- > -- Howard. > From howard.lovatt at gmail.com Thu Jun 20 00:47:21 2013 From: howard.lovatt at gmail.com (Howard Lovatt) Date: Thu, 20 Jun 2013 17:47:21 +1000 Subject: Extending Collector to handle a post-transform In-Reply-To: <51BB8499.7060702@oracle.com> References: <1E45AE50-35CF-4005-ACEB-B5612D3BCE3D@oracle.com> <51B75883.5070100@oracle.com> <2C61A79B-1C05-4D08-A0E5-4A9F89269D37@oracle.com> <51BB8499.7060702@oracle.com> Message-ID: I think the concepts in Ypnos are very good balance between power and API surface area, e.g. they have reduce and reduceR (the former is a simple reducer/collector and the latter the complicated one with intermediate types). Ypnos also has other useful features like grids of data as well as streams and the ability to map iteratively, their iterate and iterateT operators. Are there plans for these features, grids and iterative mapping, in future versions of the Stream library? On 15 June 2013 07:01, Brian Goetz wrote: > BTW, this notion of a parallel reduction as a quad of functions: > (initial-result, accumulate-element, merge-result, final-transform) shows > up in a lot of places. Here are just two that were pointed out to us as we > explored this feature: > > User defined aggregates in MS SQL Server: http://technet.microsoft.com/** > en-us/library/ms131051(v=sql.**90).aspx(Thanks Erik for this pointer.) > > Ypnos: declarative, parallel structured grid programming. ( > http://doi.acm.org/10.1145/**1708046.1708053), > which describes a Haskell-hosted EDSL for parallel stencil computations: > > Some reductions generate values of a different type to the element type > of a grid. A structure called a > Reducer packs together a number of functions for parallel reduction > under reduction operators of this type. > The mkReducer constructor builds a Reducer, taking four parameters: > > ? A function reducing an element and partially-reduced value to > another partially-reduced value: (a ? b ? b) > > ? A function combining two partially-reduced values, possibly from > two reduction processes on subgrids: (b ? b ? b) > > ? An initial partial result: b > > ? A final conversion function that converts the partial-result to > a final value: (b ? c). > > (Thanks Guy for this pointer.) > > In addition, we got requests for this feature from the Oracle "Sumatra" > team, which is exploring the practicality of transparently translating Java > bulk operations to run on GPUs. The notions from the "Ypnos" paper above > show up all over the GPGPU literature. > > > > > On 6/12/2013 11:39 PM, Mike Duigou wrote: > >> >> On Jun 11 2013, at 10:04 , Brian Goetz wrote: >> >> What's bad? >>>> >>>> - More generics in Collector signatures. For Collectors that don't >>>> want to export their intermediate type, they are declared as Collector>>> ?, R>, which users may find disturbing. (The obvious attempts to make the >>>> extra type arg go away don't work.) >>>> >>> >> For me this extra type parameter for the intermediary on Collector is no >> different than the extra type param on BaseStream. Any time you have a type >> variable that is not part of the user's generification it's going to feel >> uncomfortable. For Collector the extra param goes largely un-noticed though >> Collector is rarely assigned. Collector is mostly used as an argument and >> in this case the wildcard is invisible. The types (and wildcards) just flow >> through unobserved. This seems fine and overall it's a huge benefit to >> handle the post-transform in the Collector. >> >> Mike >> >> -- -- Howard. From paul.sandoz at oracle.com Thu Jun 20 01:01:47 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Thu, 20 Jun 2013 10:01:47 +0200 Subject: RFR (2nd round) 8009736: Comparator API cleanup In-Reply-To: <51C1EA92.9010102@oracle.com> References: <51B790E6.6020209@oracle.com> <51BCF8B6.4050307@oracle.com> <51C1EA92.9010102@oracle.com> Message-ID: <422CB789-3B08-4032-9F8E-145337AF69B1@oracle.com> On Jun 19, 2013, at 7:29 PM, Henry Jen wrote: > A ping to wake up the thread, there is a minor update regard the use of > @apiNote since last email. > > Thanks in advance for reviewing. > Looks good. Paul. > Cheers, > Henry > > > On 06/15/2013 04:28 PM, Henry Jen wrote: >> Reflecting feedbacks received so far, please see >> >> http://cr.openjdk.java.net/~henryjen/ccc/8009736.3/webrev/ >> http://cr.openjdk.java.net/~henryjen/ccc/8009736.3/specdiff >> >> Cheers, >> Henry >> >> >> On 06/11/2013 02:04 PM, Henry Jen wrote: >>> Hi, >>> >>> Please review http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/webrev/ >>> >>> Highlight of changes, >>> >>> - Comparators class is now only package-private implementations. The >>> public static methods have been move to other arguably more appropriate >>> places, mostly in Comparator. >>> >>> - Comparator.reverseOrder() is renamed to Comparator.reversed() >>> >>> - nullsFirst(Comparator) and nullsLast(Comparator) are introduced to >>> wrap up a comparator to be null-friendly. >>> >>> To see the API changes, found the specdiff at >>> http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/specdiff/overview-summary.html >>> >>> Cheers, >>> Henry >>> >> > From christian.mallwitz at Commerzbank.com Thu Jun 20 04:34:06 2013 From: christian.mallwitz at Commerzbank.com (Mallwitz, Christian) Date: Thu, 20 Jun 2013 13:34:06 +0200 Subject: Regression (b95): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: Hi, I'm re-reporting an issue in build 95 (build 1.8.0-ea-lambda-nightly-h4816-20130617-b95-b00). Same sample program as last time (see below): using -mx1g: serial stream works, parallel stream throwns OOM - no signs of parallelism using -mx1g -Xint: serial stream still works, parallel stream works with speed up using -mx128m -Xint: serial stream still works, parallel stream throwns OOM Thanks Christian -----Original Message----- From: lambda-dev-bounces at openjdk.java.net [mailto:lambda-dev-bounces at openjdk.java.net] On Behalf Of Mallwitz, Christian Sent: Tuesday, June 04, 2013 1:02 PM To: 'lambda-dev at openjdk.java.net' Subject: Regression (b92): OOM on filter/limit operation on unbound/parallel stream Hi, Re-reporting problem for build 92: the filter/limit on unbound, parallel stream operation behaves very weird. How weird? Well: - the serial version uses about 16M of heap, the parallel gobbles up all of the 1GB defined as max - it throws an OOM after running for hours while it is __NOT__ garbage collecting much but - the filter predicate is called on millions of elements more than what can be observed using a serial stream - I can't observe any parallelism (based on number of cores and system load - 4 cores and only 25% load) I'm using 1.8.0-ea-lambda-nightly-h4544-20130526-b92-b00 on a Windows XP 32 bit machine - VM args: -mx1g -XX:+PrintCommandLineFlags -verbose:gc -XX:+PrintGCTimeStamps My test program tries to find the first 283,146 prime numbers (which are all below 4,000,000). It executes the filter/limit operation on a serial stream first and prints out numbers tested for primality occasionally. Thanks Christian package com.snuffbumble.lambda; import java.util.stream.LongStream; import java.util.stream.Stream; public class OOM { public static void main(String... ignored) { // first 283_146 primes are all < 4_000_000 firstNPrimes(283_146, getIteratorBasedStream(false)); // only minor GC - max heap 16M firstNPrimes(283_146, getIteratorBasedStream(true)); // full GC - up to max heap 1GB and subsequent OOM } private static Stream getIteratorBasedStream(boolean produceParallelStream) { Stream s = LongStream.iterate(1L, n -> n + 1L).boxed(); return produceParallelStream ? s.parallel() : s; } private static void firstNPrimes(int n, Stream stream) { System.out.println(String.format("firstNPrimes (%8d, %5b): %8d", n, stream.isParallel(), stream .filter(OOM::isPrime) .limit(n) // limit after primality test .count())); } private static long start_millis = System.currentTimeMillis(); private static long max_n_seen = 3_999_970L; private static boolean isPrime(long n) { if (n >= max_n_seen) { System.out.println(String.format("%.3f: %d", (System.currentTimeMillis() - start_millis)/1000.0, n)); max_n_seen = n + (n/20L); // new max_n_seen 5% larger than current n } if (n <= 1) { return false; } if (n == 2) { return true; } if (n % 2 == 0) { return false; } for (int i = 3; i <= (int) Math.sqrt(n); i += 2) { if (n % i == 0) return false; } return true; } } From paul.sandoz at oracle.com Thu Jun 20 05:06:11 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Thu, 20 Jun 2013 14:06:11 +0200 Subject: Regression (b95): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: On Jun 20, 2013, at 1:34 PM, "Mallwitz, Christian" wrote: > Hi, > > I'm re-reporting an issue in build 95 (build 1.8.0-ea-lambda-nightly-h4816-20130617-b95-b00). > > Same sample program as last time (see below): > > using -mx1g: serial stream works, parallel stream throwns OOM - no signs of parallelism > using -mx1g -Xint: serial stream still works, parallel stream works with speed up > using -mx128m -Xint: serial stream still works, parallel stream throwns OOM > Thanks, the spinning should be fixed, still working on the OOM issue, it requires some tweaks to F/J CountedCompleter that i am about to try out. Paul. From brian.goetz at oracle.com Thu Jun 20 07:27:12 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Thu, 20 Jun 2013 14:27:12 +0000 Subject: hg: lambda/lambda/jdk: Additional tests to plug coverage gaps. Message-ID: <20130620142734.7C7EC4836C@hg.openjdk.java.net> Changeset: 809ffde01109 Author: briangoetz Date: 2013-06-20 10:26 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/809ffde01109 Additional tests to plug coverage gaps. Contributed-by: stuart.marks at oracle.com ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/ExplodeOpTest.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java From SmartAutoOffers at molesturundiakhrot.net Thu Jun 20 08:05:02 2013 From: SmartAutoOffers at molesturundiakhrot.net (SmartAutoOffers) Date: Thu, 20 Jun 2013 08:05:02 -0700 Subject: Price Reductions on all Vehicles Message-ID: <13534365154764135320929201880@nfo0gb.molesturundiakhrot.net> Huge Summer Clearance on all Cars http://www.molesturundiakhrot.net/1353/2/209/920/1880.11tt65154764AAF7.php Unsub- http://www.molesturundiakhrot.net/1353/2/209/920/1880.11tt65154764AAF8.html The White House says President Obama would veto a Republican bill that would effectively shut down the National Labor Relations Board until certain conditions are met.Republicans have claimed the board is illegitimate since an appeals court panel ruled in January that Obama violated the Constitution when he bypassed the Senate to fill vacancies on the board.House Republicans are expected to vote this week to prevent the board from conducting business until the Senate confirms new members constituting a quorum or the Supreme Court decides the board has the authority to act. The bill isn't expected to gain traction in the Senate.The White House says that the bill would hurt the middle class and jeopardize workers' rights. The administration argues Obama's appointments were constitutional and valid. ercent surveillance of the entire border, and apprehending 90 percent of border crossers or would-be crossers -- or getting them to turn back to Mexico -- in sectors where the majority of unauthorized entries take place.As of the end of the 2010 fiscal year, the Department of Homeland Security reported achieving some level of operational control of 44 percent of the nearly 2,000-mile border, according to a Government Accountability Office report this year. Operational control was defined as the ability to detect and respond to cross-border illegal activity.In one border sector cited by GAO, the busy Tucson sector, 64 percent of people who managed to make it across the border were apprehended in 2011, while 23 percent turned back to Mexico and 13 percent got away. That meant the sector stopped or turned back 87 percent of crossers, close to the 90 percent level sought by the legislation.The new goals would be achieved by giving the Department of Homeland Security six months from the bill's enactment to create a new border security plan deploying the personnel, infrastructure and technology needed to achieve the 90 percent effectiveness rate. Also within six months, the department would have to create a plan to identify where new fencing is needed on the border. Once those plans are certified, people living here illegally could begin to apply for a provisional status allowing them to work here legally.If the 90 percent rate of apprehensio From brian.goetz at oracle.com Thu Jun 20 10:50:11 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Thu, 20 Jun 2013 17:50:11 +0000 Subject: hg: lambda/lambda/jdk: Add Collector.of factories Message-ID: <20130620175118.3EDCE48378@hg.openjdk.java.net> Changeset: a051767ef42b Author: briangoetz Date: 2013-06-20 13:49 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a051767ef42b Add Collector.of factories ! src/share/classes/java/util/stream/Collector.java ! src/share/classes/java/util/stream/Collectors.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java From henry.jen at oracle.com Thu Jun 20 12:34:58 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Thu, 20 Jun 2013 19:34:58 +0000 Subject: hg: lambda/lambda/jdk: NullComparator supports all non-null values to be equal Message-ID: <20130620193523.2AF824837E@hg.openjdk.java.net> Changeset: 0ca783c9c628 Author: henryjen Date: 2013-06-20 12:34 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0ca783c9c628 NullComparator supports all non-null values to be equal ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Comparators.java From brian.goetz at oracle.com Thu Jun 20 13:42:35 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Thu, 20 Jun 2013 20:42:35 +0000 Subject: hg: lambda/lambda/jdk: Fix doc that had become out of sync with code Message-ID: <20130620204300.ED99048387@hg.openjdk.java.net> Changeset: ba022e75320a Author: briangoetz Date: 2013-06-20 16:42 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/ba022e75320a Fix doc that had become out of sync with code ! src/share/classes/java/util/DoubleSummaryStatistics.java ! src/share/classes/java/util/IntSummaryStatistics.java ! src/share/classes/java/util/LongSummaryStatistics.java ! src/share/classes/java/util/stream/Collectors.java ! src/share/classes/java/util/stream/package-info.java From brian.goetz at oracle.com Thu Jun 20 13:43:55 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Thu, 20 Jun 2013 20:43:55 +0000 Subject: hg: lambda/lambda/jdk: Standard numerics warning on Collectors.averagingDOuble Message-ID: <20130620204407.20AA248388@hg.openjdk.java.net> Changeset: 205011975bf4 Author: briangoetz Date: 2013-06-20 16:43 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/205011975bf4 Standard numerics warning on Collectors.averagingDOuble ! src/share/classes/java/util/stream/Collectors.java From henry.jen at oracle.com Thu Jun 20 15:36:00 2013 From: henry.jen at oracle.com (Henry Jen) Date: Thu, 20 Jun 2013 15:36:00 -0700 Subject: RFR (2nd round) 8009736: Comparator API cleanup In-Reply-To: <51C332D3.7090702@oracle.com> References: <51B790E6.6020209@oracle.com> <51BCF8B6.4050307@oracle.com> <51C1EA92.9010102@oracle.com> <51C332D3.7090702@oracle.com> Message-ID: <51C383D0.7080006@oracle.com> On 06/20/2013 09:50 AM, Ivan Gerasimov wrote: >>Returns a comparator compares {@link Comparable} type in natural order. > > Shouldn't be "Returns a comparator that compares"? > Fixed, I updated the webrev with this and a minor update for NullComparator. The difference from previous webrev is in following changeset, http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0ca783c9c628 Cheers, Henry From michael.hixson at gmail.com Thu Jun 20 15:45:10 2013 From: michael.hixson at gmail.com (Michael Hixson) Date: Thu, 20 Jun 2013 15:45:10 -0700 Subject: RFR (2nd round) 8009736: Comparator API cleanup In-Reply-To: <51C383D0.7080006@oracle.com> References: <51B790E6.6020209@oracle.com> <51BCF8B6.4050307@oracle.com> <51C1EA92.9010102@oracle.com> <51C332D3.7090702@oracle.com> <51C383D0.7080006@oracle.com> Message-ID: + return new NullComparator(nullFirst, real == null ? null : real.thenComparing(other)); Should that be "other" instead of the second "null", like this? + return new NullComparator(nullFirst, real == null ? other : real.thenComparing(other)); Also, if Comparator.nullsFirst(null) and nullsLast(null) no longer throw, I think it's worth mentioning what their behavior is in the javadocs. My suggestion: "If the specified comparator is {@code null}, then the returned comparator considers all non-null values to be equal." -Michael On Thu, Jun 20, 2013 at 3:36 PM, Henry Jen wrote: > On 06/20/2013 09:50 AM, Ivan Gerasimov wrote: >>>Returns a comparator compares {@link Comparable} type in natural order. >> >> Shouldn't be "Returns a comparator that compares"? >> > > Fixed, I updated the webrev with this and a minor update for NullComparator. > > The difference from previous webrev is in following changeset, > > http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0ca783c9c628 > > Cheers, > Henry > From henry.jen at oracle.com Thu Jun 20 16:40:32 2013 From: henry.jen at oracle.com (Henry Jen) Date: Thu, 20 Jun 2013 16:40:32 -0700 Subject: RFR (2nd round) 8009736: Comparator API cleanup In-Reply-To: References: <51B790E6.6020209@oracle.com> <51BCF8B6.4050307@oracle.com> <51C1EA92.9010102@oracle.com> <51C332D3.7090702@oracle.com> <51C383D0.7080006@oracle.com> Message-ID: <51C392F0.8070507@oracle.com> On 06/20/2013 03:45 PM, Michael Hixson wrote: > + return new NullComparator(nullFirst, real == null ? null : > real.thenComparing(other)); > > Should that be "other" instead of the second "null", like this? > > + return new NullComparator(nullFirst, real == null ? other : > real.thenComparing(other)); > > Also, if Comparator.nullsFirst(null) and nullsLast(null) no longer > throw, I think it's worth mentioning what their behavior is in the > javadocs. My suggestion: > > "If the specified comparator is {@code null}, then the returned > comparator considers all non-null values to be equal." > You are right on both, both fixed and added extra test. http://hg.openjdk.java.net/lambda/lambda/jdk/rev/197698000f78 webrev updated. Cheers, Henry From henry.jen at oracle.com Thu Jun 20 16:18:06 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Thu, 20 Jun 2013 23:18:06 +0000 Subject: hg: lambda/lambda/jdk: Bug fix and clarify javadoc for null-friendly comparator Message-ID: <20130620231826.D5B4548393@hg.openjdk.java.net> Changeset: 197698000f78 Author: henryjen Date: 2013-06-20 15:58 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/197698000f78 Bug fix and clarify javadoc for null-friendly comparator ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Comparators.java ! test/java/util/Comparator/BasicTest.java From paul.sandoz at oracle.com Fri Jun 21 02:25:30 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Fri, 21 Jun 2013 09:25:30 +0000 Subject: hg: lambda/lambda/jdk: 2 new changesets Message-ID: <20130621092620.CCED9483CD@hg.openjdk.java.net> Changeset: 8c51cc1a84e6 Author: psandoz Date: 2013-06-21 11:03 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8c51cc1a84e6 Add CC.helpComplete Contributed-by: Doug Lea
! src/share/classes/java/util/concurrent/CountedCompleter.java ! src/share/classes/java/util/concurrent/ForkJoinPool.java ! src/share/classes/java/util/concurrent/ForkJoinTask.java ! src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java Changeset: ad41f42ffd4e Author: psandoz Date: 2013-06-21 11:03 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/ad41f42ffd4e Let the task help out trying to complete rather than fork if aggressive forking would unduly increase memory usage and potentially result in out of memeory errors under reasonable maximum heap sizes. ! src/share/classes/java/util/stream/AbstractTask.java From paul.sandoz at oracle.com Fri Jun 21 02:40:09 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Fri, 21 Jun 2013 11:40:09 +0200 Subject: Regression (b95): OOM on filter/limit operation on unbound/parallel stream In-Reply-To: References: <50C34AAE.4498.1080E1A4@v.a.ammodytes.googlemail.com> <50C658A9.30607@oracle.com> <50C6C51C.8080903@oracle.com> <5170404B.9000708@oracle.com> <5171274C.1080606@oracle.com> <51713C14.10009@oracle.com> Message-ID: <4D2A9AE7-1240-434E-A828-253F32D4F42D@oracle.com> Hi Christian, I just pushed some changes to F/J from Doug, and changes to AbstractTask. I can get the max heap size down to -mx27m before it throws OOME with your test case. Generally parallel execution will almost always use up more memory than sequential execution, but i think we are down to reasonable levels here. Quite clearly requiring 1g or more is not reasonable! Thanks, Paul. On Jun 20, 2013, at 2:06 PM, Paul Sandoz wrote: > > On Jun 20, 2013, at 1:34 PM, "Mallwitz, Christian" wrote: > >> Hi, >> >> I'm re-reporting an issue in build 95 (build 1.8.0-ea-lambda-nightly-h4816-20130617-b95-b00). >> >> Same sample program as last time (see below): >> >> using -mx1g: serial stream works, parallel stream throwns OOM - no signs of parallelism >> using -mx1g -Xint: serial stream still works, parallel stream works with speed up >> using -mx128m -Xint: serial stream still works, parallel stream throwns OOM >> > > Thanks, the spinning should be fixed, still working on the OOM issue, it requires some tweaks to F/J CountedCompleter that i am about to try out. > > Paul. > From zhong.j.yu at gmail.com Fri Jun 21 07:41:48 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Fri, 21 Jun 2013 09:41:48 -0500 Subject: Utilities of auto close Message-ID: EG is discussing the issue of closing a Stream that ties to IO resources, and I'd like to throw in my 2 cents. Background: some new IO methods return Stream of things, for example class Files /** return a stream of entries in the dir */ static Stream list(Path dir); The problem is some IO resources are tied up and they need to be freed as soon as the Stream is no longer used. The current solution is interface CloseableStream extends Stream, AutoCloseable static CloseableStream list(Path dir); EG is discussing an alternative that makes all Streams AutoCloseable interface Stream extends AutoCloseable Some disagree with that approach, since most Streams do not need to be closed. == My proposal: It's better to move the business of close() away from Stream to some surrounding constructs. For example: try(Scope scope = Scope.newInstance()) { Stream entries = Files.list(scope, dir); } interface Scope extends AutoCloseable { void onClose(Runnable action); void close(); } static Stream list(Scope scope, Path dir) { ... scope.onClose( ()->{ free resources } ); ... } Scope provides generic destructor-like functionality, orthogonal to resource types. Zhong Yu From brendentowey at gmail.com Fri Jun 21 12:39:08 2013 From: brendentowey at gmail.com (Brenden Towey) Date: Fri, 21 Jun 2013 12:39:08 -0700 Subject: First lambda, formatter for StringJoiner? Message-ID: <51C4ABDC.7090203@gmail.com> Hi all, I played around with the Java 8 early access build for the first time last week. Overall it was fun and I learned a bit. One thing struck me looking at the Collectors.toStringJoiner() method: StringJoiner is pretty neat but it could use a formatter string, like java.util.Formatter. It's a common pattern to need to format objects as one collects them into a string. For example, a stream of bytes will often need to be formatted as two character hexidecimal strings, rather than the default decimal representation. Adding a formatter string both to StringJoiner's ctor as well as to the static convenience method in Collectors would be a big boon to Java programmers everywhere. OK, that's my 2 cents! Good luck folks. Brenden From brian.goetz at oracle.com Fri Jun 21 13:34:11 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Fri, 21 Jun 2013 20:34:11 +0000 Subject: hg: lambda/lambda/jdk: Final spec and API tweaks to Optional Message-ID: <20130621203443.8B75B483F7@hg.openjdk.java.net> Changeset: bc8ab76ab484 Author: briangoetz Date: 2013-06-21 16:34 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/bc8ab76ab484 Final spec and API tweaks to Optional ! src/share/classes/java/util/Optional.java ! test/java/util/Optional/Basic.java From nicholas+openjdk at nicholaswilliams.net Sun Jun 23 10:59:31 2013 From: nicholas+openjdk at nicholaswilliams.net (Nick Williams) Date: Sun, 23 Jun 2013 12:59:31 -0500 Subject: Invalid method reference with generics Message-ID: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> Given this interface: public interface ApplicationListener extends EventListener { void onApplicationEvent(E e); } And these two events: public class Event2 extends ApplicationEvent { public Event1(Object source) { super(source); } } public class Event2 extends ApplicationEvent { public Event2(Object source) { super(source); } } And this class: public class MyBean { public void onEvent1(Event1 event1) { } public void onEvent2(Event2 event2) { } public void initialize() { register(this::onEvent2); } public static void register(ApplicationListener listener) { } // I've also tried public static void register(ApplicationListener listener) { } // I've also tried public static void register(ApplicationListener listener) { } // I've also tried public static void register(ApplicationListener listener) { } } Can someone tell my why this fails to compile with the following error? Error: java: incompatible types: invalid method reference incompatible types: x.x.x.ApplicationEvent cannot be converted to x.x.x.Event2 This seems like quite the limitation. Why can't the compiler match onEvent2 to the method in ApplicationEvent? If I change onEvent2's signature to take an ApplicationEvent instead of an Event2, it compiles fine. If I change register's signature to take an ApplicationListener instead of an ApplicationListener, it also compiles fine. Is there some other way to do what I want to do here? Note: I also tried public static void register(ApplicationListener listener) { }, but that resulted in a different error, "Error: java: incompatible types: Cannot instantiate inference variables E because of an inference loop." Nick From cleber at nightcoders.com.br Sun Jun 23 13:45:47 2013 From: cleber at nightcoders.com.br (Cleber Muramoto) Date: Sun, 23 Jun 2013 17:45:47 -0300 Subject: lambda-dev Digest, Vol 43, Issue 39 In-Reply-To: References: Message-ID: I'd rather have Stream implementing AutoCloseable. In my humble opinion, .Net got it right by making IEnumerable extend IDisposable. One can work with the same 'contracts' and does not need to bother (from a pure code perspective) if the stuff is coming from the memory or from the database or from anywhere else. The good: -No need for another indirection -Code more concise The bad: -Ide's complaing that you're leaking a resource if you do not wrap every stream in a try(...) -May induce 'generic' programing with thousands of unnecessary try(..){ } blocks (the penalty however, is negligible comparing to consuming the stream itself) Anyway, I would like the API to be consistent enough to support use cases beyond (java) I/O or SQL ops, but for anything that might require explicit resource release - either to avoid resource leaks or so release cache-like data structures after a unit of work is done. Maybe your proposal could be achieved via composition as well, at the expense of delegating every call to a wrapped downstream. interface Stream{ //... default ACS asCloseable(Callable onClose){ return new ACS(this,onClose); } } final class ACS implements Stream,AutoCloseable{ Callable onClose; Stream del; //delegates everyhing to del public void close(){ try{ onClose.call(); }catch(... e){ throw RTE(e); } } } While your Scope interface makes it clear that one is working with resources that must be manually released, I don't like the extra-verbosity. :) I think, however, that it might make the work easier, e.g., for implementing stuff like generators , in the future: IntStream getAllIds(){ try(ResultSet rs = ...){ while(rs.next()){ yield rs.getInt(1); } } } (This could be ambiguous: rs.close should be called once stream.close is called or when the loop is over?) IntStream getAllIds(Scope s){ ResultSet rs = ...; s.onClose(()->{rs.close();}); while(rs.next()){ yield rs.getInt(1); } } (Not ambiguous-but "feels like" there's a resource leak!) On Fri, Jun 21, 2013 at 4:00 PM, wrote: > > 10. Utilities of auto close (Zhong Yu) > > > ---------------------------------------------------------------------- > > > Message: 10 > Date: Fri, 21 Jun 2013 09:41:48 -0500 > From: Zhong Yu > Subject: Utilities of auto close > To: "lambda-dev at openjdk.java.net" > Message-ID: > N6yAEU8w4++g9Dozn-g at mail.gmail.com> > Content-Type: text/plain; charset=ISO-8859-1 > > EG is discussing the issue of closing a Stream that ties to IO > resources, and I'd like to throw in my 2 cents. > > Background: some new IO methods return Stream of things, for example > > class Files > /** return a stream of entries in the dir */ > static Stream list(Path dir); > > The problem is some IO resources are tied up and they need to be freed > as soon as the Stream is no longer used. > > The current solution is > > interface CloseableStream extends Stream, AutoCloseable > > static CloseableStream list(Path dir); > > EG is discussing an alternative that makes all Streams AutoCloseable > > interface Stream extends AutoCloseable > > Some disagree with that approach, since most Streams do not need to be > closed. > > == > My proposal: > > It's better to move the business of close() away from Stream to some > surrounding constructs. For example: > > try(Scope scope = Scope.newInstance()) > { > Stream entries = Files.list(scope, dir); > } > > interface Scope extends AutoCloseable > { > void onClose(Runnable action); > > void close(); > } > > static Stream list(Scope scope, Path dir) > { > ... > scope.onClose( ()->{ free resources } ); > ... > } > > > Scope provides generic destructor-like functionality, orthogonal to > resource types. > > Zhong Yu > > > End of lambda-dev Digest, Vol 43, Issue 39 > ****************************************** > From howard.lovatt at gmail.com Sun Jun 23 17:06:31 2013 From: howard.lovatt at gmail.com (Howard Lovatt) Date: Mon, 24 Jun 2013 10:06:31 +1000 Subject: lambda-dev Digest, Vol 43, Issue 39 In-Reply-To: References: Message-ID: I did hold the view that implementing AutoCloseable was a good idea, so I tried it in my own code (I have my own Stream library). However for me it didn't work out well because the IDE complained so much about lack of try blocks (that in my case were all unnecessary because of the way I implemented the stream - see below). Therefore I would in hindsight propose no AutoCloaseable, so that you write: try (SomeResource r = ...) { r.stream()....; } As an implementation note, if AutoCloseable is implemented then I found it necessary to create the resource lazily to eliminate resource leaks from code like: new SomeResource( ... ).stream().map( callToMethodThatReturnsMapperButAlsoThrowsAnException() )...collect( ... ); The problem above is that even if collect() has a try block the resource is grabbed by the new and then when the exception is thrown by callToMethodThatReturnsMapperButAlsoThrowsAnException() the resource isn't released unless the whole line is inside a try block. Instead I grab the resource lazily: Streams.from( () -> new SomeResource( ... ) ).map( callToMethodThatReturnsMapperButAlsoThrowsAnException() )...collect( ... ); Which works because the resource isn't grabbed at all if callToMethodThatReturnsMapperButAlsoThrowsAnException() throws an exception. On 24 June 2013 06:45, Cleber Muramoto wrote: > I'd rather have Stream implementing AutoCloseable. In my humble opinion, > .Net got it right by making IEnumerable extend IDisposable. One can work > with the same 'contracts' and does not need to bother (from a pure code > perspective) if the stuff is coming from the memory or from the database or > from anywhere else. > > The good: > > -No need for another indirection > -Code more concise > > The bad: > > -Ide's complaing that you're leaking a resource if you do not wrap every > stream in a try(...) > -May induce 'generic' programing with thousands of unnecessary try(..){ } > blocks (the penalty however, is negligible comparing to consuming the > stream itself) > > Anyway, I would like the API to be consistent enough to support use cases > beyond (java) I/O or SQL ops, but for anything that might require explicit > resource release - either to avoid resource leaks or so release cache-like > data structures after a unit of work is done. > > Maybe your proposal could be achieved via composition as well, at the > expense of delegating every call to a wrapped downstream. > > interface Stream{ > > //... > > default ACS asCloseable(Callable onClose){ > return new ACS(this,onClose); > } > > } > > final class ACS implements Stream,AutoCloseable{ > > Callable onClose; > Stream del; > > //delegates everyhing to del > > public void close(){ > try{ > onClose.call(); > }catch(... e){ > throw RTE(e); > } > } > > } > > While your Scope interface makes it clear that one is working with > resources that must be manually released, I don't like the extra-verbosity. > :) I think, however, that it might make the work easier, e.g., for > implementing stuff like generators , in the future: > > IntStream getAllIds(){ > > try(ResultSet rs = ...){ > while(rs.next()){ > yield rs.getInt(1); > } > } > } > > (This could be ambiguous: rs.close should be called once stream.close is > called or when the loop is over?) > > IntStream getAllIds(Scope s){ > ResultSet rs = ...; > > s.onClose(()->{rs.close();}); > > while(rs.next()){ > yield rs.getInt(1); > } > } > > (Not ambiguous-but "feels like" there's a resource leak!) > > > > On Fri, Jun 21, 2013 at 4:00 PM, >wrote: > > > > > 10. Utilities of auto close (Zhong Yu) > > > > > > ---------------------------------------------------------------------- > > > > > > Message: 10 > > Date: Fri, 21 Jun 2013 09:41:48 -0500 > > From: Zhong Yu > > Subject: Utilities of auto close > > To: "lambda-dev at openjdk.java.net" > > Message-ID: > > > N6yAEU8w4++g9Dozn-g at mail.gmail.com> > > Content-Type: text/plain; charset=ISO-8859-1 > > > > EG is discussing the issue of closing a Stream that ties to IO > > resources, and I'd like to throw in my 2 cents. > > > > Background: some new IO methods return Stream of things, for example > > > > class Files > > /** return a stream of entries in the dir */ > > static Stream list(Path dir); > > > > The problem is some IO resources are tied up and they need to be freed > > as soon as the Stream is no longer used. > > > > The current solution is > > > > interface CloseableStream extends Stream, AutoCloseable > > > > static CloseableStream list(Path dir); > > > > EG is discussing an alternative that makes all Streams AutoCloseable > > > > interface Stream extends AutoCloseable > > > > Some disagree with that approach, since most Streams do not need to be > > closed. > > > > == > > My proposal: > > > > It's better to move the business of close() away from Stream to some > > surrounding constructs. For example: > > > > try(Scope scope = Scope.newInstance()) > > { > > Stream entries = Files.list(scope, dir); > > } > > > > interface Scope extends AutoCloseable > > { > > void onClose(Runnable action); > > > > void close(); > > } > > > > static Stream list(Scope scope, Path dir) > > { > > ... > > scope.onClose( ()->{ free resources } ); > > ... > > } > > > > > > Scope provides generic destructor-like functionality, orthogonal to > > resource types. > > > > Zhong Yu > > > > > > End of lambda-dev Digest, Vol 43, Issue 39 > > ****************************************** > > > > -- -- Howard. From jed at wesleysmith.io Sun Jun 23 22:16:20 2013 From: jed at wesleysmith.io (Jed Wesley-Smith) Date: Mon, 24 Jun 2013 15:16:20 +1000 Subject: Utilities of auto close In-Reply-To: References: Message-ID: What about loan pattern: interface Managed { doManaged(Function f) } usage is: Managed mgr = new Managed() { public B doManaged(doManaged(Function f) { Stream stream = open(); try { f(stream); } finally { close(stream); } } } On 22 June 2013 00:41, Zhong Yu wrote: > EG is discussing the issue of closing a Stream that ties to IO > resources, and I'd like to throw in my 2 cents. > > Background: some new IO methods return Stream of things, for example > > class Files > /** return a stream of entries in the dir */ > static Stream list(Path dir); > > The problem is some IO resources are tied up and they need to be freed > as soon as the Stream is no longer used. > > The current solution is > > interface CloseableStream extends Stream, AutoCloseable > > static CloseableStream list(Path dir); > > EG is discussing an alternative that makes all Streams AutoCloseable > > interface Stream extends AutoCloseable > > Some disagree with that approach, since most Streams do not need to be > closed. > > == > My proposal: > > It's better to move the business of close() away from Stream to some > surrounding constructs. For example: > > try(Scope scope = Scope.newInstance()) > { > Stream entries = Files.list(scope, dir); > } > > interface Scope extends AutoCloseable > { > void onClose(Runnable action); > > void close(); > } > > static Stream list(Scope scope, Path dir) > { > ... > scope.onClose( ()->{ free resources } ); > ... > } > > > Scope provides generic destructor-like functionality, orthogonal to > resource types. > > Zhong Yu > > From peter.levart at gmail.com Mon Jun 24 01:31:29 2013 From: peter.levart at gmail.com (Peter Levart) Date: Mon, 24 Jun 2013 10:31:29 +0200 Subject: forEach/forEachOrdered/forEachRemaining ... iterate? In-Reply-To: <51B9EA60.6040608@oracle.com> References: <51B9DB88.5000107@gmail.com> <51B9EA60.6040608@oracle.com> Message-ID: <51C803E1.1010405@gmail.com> On 06/13/2013 05:50 PM, Brian Goetz wrote: > It's a mess for sure, but I am not sure whether this is a good path > out of the forest. There are only so many candidate names, and the > "try and give every unique semantics a unique name" eventually > degenerates into them all being some form of "forEach #352", where the > user code is still not readable without a decoder chart. > > Here are some of the dimensions covered here: > > - data arity (Consumer vs BiConsumer) > - data projection (element, map key, map value) > - sequential vs parallel > - whether to prefer encounter (spatial) or temporal order > - more... > > It is impossible for a name to be readable and writable and still > precisely convey all the dimensions here; forEach is fuzzy, > forEachKeyParallelInEncounterOrder is precise but awful. I don't know > what the difference between iterate and forEach should be; I could > learn, but it will never be obvious because of the way our brains map > words to concepts. > > Without overloading names, it is already spiraling out of control. > The goal here was for "forEach" to be the natural behavior for the > thing being iterated; for a sequential stream, that is a sequential > encounter-order traversal and for a parallel stream, that is a > parallel temporal-order traversal. Variants of forEach (like > forEachOrdered) allow you to select the less natural variant. (*I > would rather get rid of forEachRemaining and make them "forEach" also.*) +1 I think that majority of usages will be iterating over the whole set of elements in one go, not doing any external iteration steps before calling forEachRemaining. I recently played with constructing an API based on Iterator and this "forEachRemaining" really stands out when I read it, making me wonder why the "Remaining" part is so important to be explicitly spelled out and to be taking precious space in code, obfuscating the really important part, the "forEach". Even if the semantics of Iterator.forEach were not explicitly described in javadoc, many users would implicitly assume the "Remaining" semantics, since they are used to the fact that with Iterator API, you can't go back once you consume an element. So I think the javadoc is more than enough to clear-up any doubts and the "Remaining" method suffix could be dropped. Regards, Peter > > > > > On 6/13/2013 10:47 AM, Peter Levart wrote: >> I know it's a little late, but let's look at current situation. There >> are 5 methods in current APIs with similar names and signatures + 1 >> additional with a little different signature in Map + some similarly >> named methods in ConcurrentHashMap: >> >> interface Stream { >> void forEach(Consumer action) >> void forEachOrdered(Consumer action) >> } >> >> interface Iterable { >> void forEach(Consumer action) >> } >> >> interface Iterator { >> void forEachRemaining(Consumer action) >> } >> >> interface Spliterator { >> void forEachRemaining(Consumer action) >> } >> >> interface Map { >> void forEach(BiConsumer action) >> } >> >> class ConcurrentHashMap ... { >> void forEachKey(long parallelismThreshold, >> Consumer action) >> void forEachKey(long parallelismThreshold, >> Function transformer, >> Consumer action) >> void forEachValue(long parallelismThreshold, >> Consumer action) >> void forEachValue(long parallelismThreshold, >> Function >> transformer, >> Consumer action) >> } >> >> >> I'm wondering if the following alternative would be easier to read and >> reason-about in code: >> >> interface Stream { >> void forEach(Consumer action) >> void iterate(Consumer action) >> } >> >> interface Iterable { >> void iterate(Consumer action) >> } >> >> interface Iterator { >> void iterateRemaining(Consumer action) >> } >> >> interface Spliterator { >> void iterateRemaining(Consumer action) >> } >> >> interface Map { >> void iterate(BiConsumer action) >> } >> >> class ConcurrentHashMap ... { >> void forEachKey(long parallelismThreshold, >> Consumer action) >> void forEachKey(long parallelismThreshold, >> Function transformer, >> Consumer action) >> void forEachValue(long parallelismThreshold, >> Consumer action) >> void forEachValue(long parallelismThreshold, >> Function >> transformer, >> Consumer action) >> } >> >> >> Why? I'm a little concerned about the duality of Stream.forEach() and >> Iterable.forEach(). While the later is always sequential and >> encounter-ordered, the former can be executed out-of order and/or >> in-parallel. I think that by naming the sequential variants differently, >> the reader of code need not be concerned about the type of the target >> that the method is invoked upon, just the name. This enables fast >> browsing of code where the eye can quickly glance over iterate()s but >> slows down on each forEach()... >> >> How do others feel about the (re)use of forEach... names in different >> APIs? Would it be more difficult to find the right method if iterate() >> was used instead of forEach() for iteration? >> >> >> Regards, Peter >> >> From paul.sandoz at oracle.com Mon Jun 24 01:38:59 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Mon, 24 Jun 2013 10:38:59 +0200 Subject: First lambda, formatter for StringJoiner? In-Reply-To: <51C4ABDC.7090203@gmail.com> References: <51C4ABDC.7090203@gmail.com> Message-ID: HI Brendan, You can use a map operation to format elements to a String before collecting. BTW the latest source code renamed toStringJoiner to joining and now hides the use of the StringJoiner class. Paul. On Jun 21, 2013, at 9:39 PM, Brenden Towey wrote: > Hi all, > > I played around with the Java 8 early access build for the first time > last week. Overall it was fun and I learned a bit. One thing struck me > looking at the Collectors.toStringJoiner() method: > > StringJoiner is pretty neat but it could use a formatter string, like > java.util.Formatter. It's a common pattern to need to format objects as > one collects them into a string. For example, a stream of bytes will > often need to be formatted as two character hexidecimal strings, rather > than the default decimal representation. > > Adding a formatter string both to StringJoiner's ctor as well as to the > static convenience method in Collectors would be a big boon to Java > programmers everywhere. > > OK, that's my 2 cents! Good luck folks. > > Brenden > > > From forax at univ-mlv.fr Mon Jun 24 02:41:27 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Mon, 24 Jun 2013 11:41:27 +0200 Subject: forEach/forEachOrdered/forEachRemaining ... iterate? In-Reply-To: <51C803E1.1010405@gmail.com> References: <51B9DB88.5000107@gmail.com> <51B9EA60.6040608@oracle.com> <51C803E1.1010405@gmail.com> Message-ID: <51C81447.7050403@univ-mlv.fr> On 06/24/2013 10:31 AM, Peter Levart wrote: > On 06/13/2013 05:50 PM, Brian Goetz wrote: >> It's a mess for sure, but I am not sure whether this is a good path >> out of the forest. There are only so many candidate names, and the >> "try and give every unique semantics a unique name" eventually >> degenerates into them all being some form of "forEach #352", where the >> user code is still not readable without a decoder chart. >> >> Here are some of the dimensions covered here: >> >> - data arity (Consumer vs BiConsumer) >> - data projection (element, map key, map value) >> - sequential vs parallel >> - whether to prefer encounter (spatial) or temporal order >> - more... >> >> It is impossible for a name to be readable and writable and still >> precisely convey all the dimensions here; forEach is fuzzy, >> forEachKeyParallelInEncounterOrder is precise but awful. I don't know >> what the difference between iterate and forEach should be; I could >> learn, but it will never be obvious because of the way our brains map >> words to concepts. >> >> Without overloading names, it is already spiraling out of control. >> The goal here was for "forEach" to be the natural behavior for the >> thing being iterated; for a sequential stream, that is a sequential >> encounter-order traversal and for a parallel stream, that is a >> parallel temporal-order traversal. Variants of forEach (like >> forEachOrdered) allow you to select the less natural variant. (*I >> would rather get rid of forEachRemaining and make them "forEach" also.*) > +1 > > I think that majority of usages will be iterating over the whole set of > elements in one go, not doing any external iteration steps before > calling forEachRemaining. I recently played with constructing an API > based on Iterator and this "forEachRemaining" really stands out when I > read it, making me wonder why the "Remaining" part is so important to be > explicitly spelled out and to be taking precious space in code, > obfuscating the really important part, the "forEach". There is no point to use the same name for things that are semantically different. By example, iterator.forEachRemaining(e -> {...}); iterator.remove(); is a valid code. Now, for the name, it's sometimes useful to separate the first object from the following ones, if (!iterator.hasNext()) { return ""; } StringBuilder builder = new StringBuilder(); builder.append(it.next()); iterator.forEachRemaining( element -> { builder.append(", ").append(element); }); return builder.toString(); > > Even if the semantics of Iterator.forEach were not explicitly described > in javadoc, many users would implicitly assume the "Remaining" > semantics, since they are used to the fact that with Iterator API, you > can't go back once you consume an element. So I think the javadoc is > more than enough to clear-up any doubts and the "Remaining" method > suffix could be dropped. If you have only the method forEach and a class that implement Iterator and Iterable (why is not the problem here :), then you are in trouble to provide the code of forEach given the semantics for iterating over an Iterable and iterating over an Iterator is not the same. > > Regards, Peter cheers, R?mi > >> >> >> >> On 6/13/2013 10:47 AM, Peter Levart wrote: >>> I know it's a little late, but let's look at current situation. There >>> are 5 methods in current APIs with similar names and signatures + 1 >>> additional with a little different signature in Map + some similarly >>> named methods in ConcurrentHashMap: >>> >>> interface Stream { >>> void forEach(Consumer action) >>> void forEachOrdered(Consumer action) >>> } >>> >>> interface Iterable { >>> void forEach(Consumer action) >>> } >>> >>> interface Iterator { >>> void forEachRemaining(Consumer action) >>> } >>> >>> interface Spliterator { >>> void forEachRemaining(Consumer action) >>> } >>> >>> interface Map { >>> void forEach(BiConsumer action) >>> } >>> >>> class ConcurrentHashMap ... { >>> void forEachKey(long parallelismThreshold, >>> Consumer action) >>> void forEachKey(long parallelismThreshold, >>> Function transformer, >>> Consumer action) >>> void forEachValue(long parallelismThreshold, >>> Consumer action) >>> void forEachValue(long parallelismThreshold, >>> Function >>> transformer, >>> Consumer action) >>> } >>> >>> >>> I'm wondering if the following alternative would be easier to read and >>> reason-about in code: >>> >>> interface Stream { >>> void forEach(Consumer action) >>> void iterate(Consumer action) >>> } >>> >>> interface Iterable { >>> void iterate(Consumer action) >>> } >>> >>> interface Iterator { >>> void iterateRemaining(Consumer action) >>> } >>> >>> interface Spliterator { >>> void iterateRemaining(Consumer action) >>> } >>> >>> interface Map { >>> void iterate(BiConsumer action) >>> } >>> >>> class ConcurrentHashMap ... { >>> void forEachKey(long parallelismThreshold, >>> Consumer action) >>> void forEachKey(long parallelismThreshold, >>> Function transformer, >>> Consumer action) >>> void forEachValue(long parallelismThreshold, >>> Consumer action) >>> void forEachValue(long parallelismThreshold, >>> Function >>> transformer, >>> Consumer action) >>> } >>> >>> >>> Why? I'm a little concerned about the duality of Stream.forEach() and >>> Iterable.forEach(). While the later is always sequential and >>> encounter-ordered, the former can be executed out-of order and/or >>> in-parallel. I think that by naming the sequential variants differently, >>> the reader of code need not be concerned about the type of the target >>> that the method is invoked upon, just the name. This enables fast >>> browsing of code where the eye can quickly glance over iterate()s but >>> slows down on each forEach()... >>> >>> How do others feel about the (re)use of forEach... names in different >>> APIs? Would it be more difficult to find the right method if iterate() >>> was used instead of forEach() for iteration? >>> >>> >>> Regards, Peter >>> >>> > From peter.levart at gmail.com Mon Jun 24 06:31:20 2013 From: peter.levart at gmail.com (Peter Levart) Date: Mon, 24 Jun 2013 15:31:20 +0200 Subject: forEach/forEachOrdered/forEachRemaining ... iterate? In-Reply-To: <51C81447.7050403@univ-mlv.fr> References: <51B9DB88.5000107@gmail.com> <51B9EA60.6040608@oracle.com> <51C803E1.1010405@gmail.com> <51C81447.7050403@univ-mlv.fr> Message-ID: <51C84A28.3070702@gmail.com> On 06/24/2013 11:41 AM, Remi Forax wrote: > If you have only the method forEach and a class that implement > Iterator and Iterable (why is not the problem here:), then you are > in trouble to provide the code of forEach given the semantics for > iterating over an Iterable and iterating over an Iterator is not the same. Well, I haven't thought of that. Regards, Peter From boaznahum at gmail.com Mon Jun 24 07:36:00 2013 From: boaznahum at gmail.com (Boaz Nahum) Date: Mon, 24 Jun 2013 17:36:00 +0300 Subject: Comparator and Comparators Message-ID: Hi Now we have two places to look for factory methods: Comparator Comparators What is the rule ? Stream factories are in Stream, Collection factories are in Collections (nothing we can do about it) Collector are in Collectors function.* are in function.* I know it is not big issue. Thank Boaz From brian.goetz at oracle.com Mon Jun 24 07:48:55 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Mon, 24 Jun 2013 10:48:55 -0400 Subject: Comparator and Comparators In-Reply-To: References: Message-ID: <51C85C57.3090608@oracle.com> For this issue, Comparators will be going away soon as a public class, and its members sent to various places: - Comparator for common comparator factories - BinaryOperator for Comparator-to-BinaryOperator transforms - Map.Entry for specialized comparators on Map.Entry You can see this in lambda repo if you're interested. In general, people who want to believe "I can put static methods in interfaces now, so code that used to go in class Foos now belongs in interface Foo" will be disappointed (if they're smart). The set of methods that are acceptable in a "statics dumping ground" class Foos are not necessarily the same set as would be appropriate in the Foo interface. Judgment and taste is required. On 6/24/2013 10:36 AM, Boaz Nahum wrote: > Hi > > Now we have two places to look for factory methods: > > Comparator > Comparators > > What is the rule ? > > Stream factories are in Stream, > Collection factories are in Collections (nothing we can do about it) > Collector are in Collectors > function.* are in function.* > > I know it is not big issue. > > Thank > Boaz > From zhong.j.yu at gmail.com Mon Jun 24 07:54:08 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Mon, 24 Jun 2013 09:54:08 -0500 Subject: Utilities of auto close In-Reply-To: References: Message-ID: I agree with you and Jeb that returning a wrapped Stream is better than returning a Stream that inherits Closeable. The wrapper is more generic, useful for all types of resources. But I think the task of triggering clean up should not be on individual resources, but rather on a enclosing lexical scope. I feel the latter pattern result in more pleasant code. For example try(Scope scope = Scope.newInstance()) { InputStream input = new FileInputStream(src); scope.onClose(input::close); OutputStream output = new FileOutputStream(dest); scope.onClose(output::close); ... } It's subjective, of course. Zhong Yu On Mon, Jun 24, 2013 at 6:35 AM, Samir Talwar wrote: > I don't like the idea of mutable scopes. This seems like it could introduce > a whole unnecessary class of bugs. I'd prefer to just replace the > inheritance with composition using your scope metaphor. > > try (IterableScope scope = Files.list(dir)) { > Stream entries = scope.stream(); > // do stuff with entries > } > > interface IterableScope extends Iterable, AutoCloseable { } > > The name is not so important, but the idea would be to separate the concepts > of iteration and scoping so that the user has to deal with them both, > instead of accidentally storing the CloseableStream as a Stream and > forgetting to close it. > > ? Samir. > > On 21 Jun 2013 15:48, "Zhong Yu" wrote: >> >> EG is discussing the issue of closing a Stream that ties to IO >> resources, and I'd like to throw in my 2 cents. >> >> Background: some new IO methods return Stream of things, for example >> >> class Files >> /** return a stream of entries in the dir */ >> static Stream list(Path dir); >> >> The problem is some IO resources are tied up and they need to be freed >> as soon as the Stream is no longer used. >> >> The current solution is >> >> interface CloseableStream extends Stream, AutoCloseable >> >> static CloseableStream list(Path dir); >> >> EG is discussing an alternative that makes all Streams AutoCloseable >> >> interface Stream extends AutoCloseable >> >> Some disagree with that approach, since most Streams do not need to be >> closed. >> >> == >> My proposal: >> >> It's better to move the business of close() away from Stream to some >> surrounding constructs. For example: >> >> try(Scope scope = Scope.newInstance()) >> { >> Stream entries = Files.list(scope, dir); >> } >> >> interface Scope extends AutoCloseable >> { >> void onClose(Runnable action); >> >> void close(); >> } >> >> static Stream list(Scope scope, Path dir) >> { >> ... >> scope.onClose( ()->{ free resources } ); >> ... >> } >> >> >> Scope provides generic destructor-like functionality, orthogonal to >> resource types. >> >> Zhong Yu >> > From pbenedict at apache.org Mon Jun 24 07:56:29 2013 From: pbenedict at apache.org (Paul Benedict) Date: Mon, 24 Jun 2013 09:56:29 -0500 Subject: Comparator and Comparators In-Reply-To: <51C85C57.3090608@oracle.com> References: <51C85C57.3090608@oracle.com> Message-ID: Brian, can you explain the "judgement and taste" is required comment? I've been trying to find some objective criteria why someone should use static method in interfaces over static utility classes. I haven't found any reason except such vague comments, which are unhelpful. I do ask in earnest what should be the driver to use this new feature over existing designs. What criteria do you use? Paul On Mon, Jun 24, 2013 at 9:48 AM, Brian Goetz wrote: > For this issue, Comparators will be going away soon as a public class, > and its members sent to various places: > - Comparator for common comparator factories > - BinaryOperator for Comparator-to-BinaryOperator transforms > - Map.Entry for specialized comparators on Map.Entry > > You can see this in lambda repo if you're interested. > > In general, people who want to believe "I can put static methods in > interfaces now, so code that used to go in class Foos now belongs in > interface Foo" will be disappointed (if they're smart). > > The set of methods that are acceptable in a "statics dumping ground" > class Foos are not necessarily the same set as would be appropriate in > the Foo interface. Judgment and taste is required. > > On 6/24/2013 10:36 AM, Boaz Nahum wrote: > > Hi > > > > Now we have two places to look for factory methods: > > > > Comparator > > Comparators > > > > What is the rule ? > > > > Stream factories are in Stream, > > Collection factories are in Collections (nothing we can do about it) > > Collector are in Collectors > > function.* are in function.* > > > > I know it is not big issue. > > > > Thank > > Boaz > > > > From paul.sandoz at oracle.com Mon Jun 24 08:02:57 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Mon, 24 Jun 2013 17:02:57 +0200 Subject: Comparator and Comparators In-Reply-To: References: Message-ID: On Jun 24, 2013, at 4:36 PM, Boaz Nahum wrote: > Hi > > Now we have two places to look for factory methods: > > Comparator > Comparators > This distinction is now removed in the tip of the repo. Some of those methods have moved to Comapator, others elsewhere. See: http://lambdadoc.net/api/java/util/Comparator.html http://lambdadoc.net/api/java/util/Map.Entry.html Paul. > What is the rule ? > > Stream factories are in Stream, > Collection factories are in Collections (nothing we can do about it) > Collector are in Collectors > function.* are in function.* > > I know it is not big issue. > > Thank > Boaz > From scolebourne at joda.org Mon Jun 24 08:14:14 2013 From: scolebourne at joda.org (Stephen Colebourne) Date: Mon, 24 Jun 2013 16:14:14 +0100 Subject: Point lambdaification of List/Set/Map Message-ID: One point lambdaification that I haven't seen mentioned is addition static factory methods for the main collection interfaces. (Strictly, this proposal is not point lambdaification as it does not involve lambdas, but it is very much in the same area). I propose adding these static methods: Collection.empty() Collection.of(T...) List.empty() List.of(T...) Set.empty() Set.of(T...) Map.empty() Map.of(Entry...) Map.Entry.of(K, V) Each of these methods would return immutable implementations. There is a case for extending the methods to Iterator and other collection types, however these are the most important. These follow the designs of Stream static methods IIRC. This library change would remove much of the requirement for the "collection literals" change discussed in Project Coin. Implementation would ideally be via new dedicated immutable classes, however space could be saved by simply reusing the existing classes. Is this something we could fit in? (Is resourcing the problem, or the idea?) thanks Stephen From brian.goetz at oracle.com Mon Jun 24 08:20:39 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Mon, 24 Jun 2013 11:20:39 -0400 Subject: Comparator and Comparators In-Reply-To: References: <51C85C57.3090608@oracle.com> Message-ID: <51C863C7.8020900@oracle.com> Yes, it sure would be nice if there were some easily communicated, objective criteria to differentiate between a "good" and "bad" API. And if you discover it, you'll be famous! But until then, designing good APIs will have as much art as science. But, if you read between the lines, there is some actionable advice here, which is that the decision of where to put static methods is not an obvious one, and that you need to expend a portion of your design budget here. On 6/24/2013 10:56 AM, Paul Benedict wrote: > Brian, can you explain the "judgement and taste" is required comment? > I've been trying to find some objective criteria why someone should use > static method in interfaces over static utility classes. I haven't found > any reason except such vague comments, which are unhelpful. I do ask in > earnest what should be the driver to use this new feature over existing > designs. What criteria do you use? > > Paul > > > On Mon, Jun 24, 2013 at 9:48 AM, Brian Goetz > wrote: > > For this issue, Comparators will be going away soon as a public class, > and its members sent to various places: > - Comparator for common comparator factories > - BinaryOperator for Comparator-to-BinaryOperator transforms > - Map.Entry for specialized comparators on Map.Entry > > You can see this in lambda repo if you're interested. > > In general, people who want to believe "I can put static methods in > interfaces now, so code that used to go in class Foos now belongs in > interface Foo" will be disappointed (if they're smart). > > The set of methods that are acceptable in a "statics dumping ground" > class Foos are not necessarily the same set as would be appropriate in > the Foo interface. Judgment and taste is required. > > On 6/24/2013 10:36 AM, Boaz Nahum wrote: > > Hi > > > > Now we have two places to look for factory methods: > > > > Comparator > > Comparators > > > > What is the rule ? > > > > Stream factories are in Stream, > > Collection factories are in Collections (nothing we can do about it) > > Collector are in Collectors > > function.* are in function.* > > > > I know it is not big issue. > > > > Thank > > Boaz > > > > From spullara at gmail.com Mon Jun 24 09:44:23 2013 From: spullara at gmail.com (Sam Pullara) Date: Mon, 24 Jun 2013 09:44:23 -0700 Subject: Utilities of auto close In-Reply-To: References: Message-ID: <736415D1-F595-4F63-9E50-FA7EB1403A8A@gmail.com> The one thing that bothers me about this discussion is that TWR would have never existed if lambdas had been in the language ? it would just be a static method in java.io somewhere. It isn't clear to me that we should be mixing them at all. It seems like we should be using something more like Jed's Managed suggestion or even less. For example, we could just add a .release() on the Stream (to make it clear that it is targeted at resource management) and have it called when either the stream is exhausted or an exception is thrown from the pipeline. For those that convert their streams to external iteration via .iterator() may the buyer beware. Sam On Jun 24, 2013, at 7:54 AM, Zhong Yu wrote: > I agree with you and Jeb that returning a wrapped Stream is better > than returning a Stream that inherits Closeable. The wrapper is more > generic, useful for all types of resources. But I think the task of > triggering clean up should not be on individual resources, but rather > on a enclosing lexical scope. I feel the latter pattern result in more > pleasant code. For example > > try(Scope scope = Scope.newInstance()) > { > InputStream input = new FileInputStream(src); > scope.onClose(input::close); > > OutputStream output = new FileOutputStream(dest); > scope.onClose(output::close); > > ... > } > > It's subjective, of course. > > Zhong Yu > > > On Mon, Jun 24, 2013 at 6:35 AM, Samir Talwar wrote: >> I don't like the idea of mutable scopes. This seems like it could introduce >> a whole unnecessary class of bugs. I'd prefer to just replace the >> inheritance with composition using your scope metaphor. >> >> try (IterableScope scope = Files.list(dir)) { >> Stream entries = scope.stream(); >> // do stuff with entries >> } >> >> interface IterableScope extends Iterable, AutoCloseable { } >> >> The name is not so important, but the idea would be to separate the concepts >> of iteration and scoping so that the user has to deal with them both, >> instead of accidentally storing the CloseableStream as a Stream and >> forgetting to close it. >> >> ? Samir. >> >> On 21 Jun 2013 15:48, "Zhong Yu" wrote: >>> >>> EG is discussing the issue of closing a Stream that ties to IO >>> resources, and I'd like to throw in my 2 cents. >>> >>> Background: some new IO methods return Stream of things, for example >>> >>> class Files >>> /** return a stream of entries in the dir */ >>> static Stream list(Path dir); >>> >>> The problem is some IO resources are tied up and they need to be freed >>> as soon as the Stream is no longer used. >>> >>> The current solution is >>> >>> interface CloseableStream extends Stream, AutoCloseable >>> >>> static CloseableStream list(Path dir); >>> >>> EG is discussing an alternative that makes all Streams AutoCloseable >>> >>> interface Stream extends AutoCloseable >>> >>> Some disagree with that approach, since most Streams do not need to be >>> closed. >>> >>> == >>> My proposal: >>> >>> It's better to move the business of close() away from Stream to some >>> surrounding constructs. For example: >>> >>> try(Scope scope = Scope.newInstance()) >>> { >>> Stream entries = Files.list(scope, dir); >>> } >>> >>> interface Scope extends AutoCloseable >>> { >>> void onClose(Runnable action); >>> >>> void close(); >>> } >>> >>> static Stream list(Scope scope, Path dir) >>> { >>> ... >>> scope.onClose( ()->{ free resources } ); >>> ... >>> } >>> >>> >>> Scope provides generic destructor-like functionality, orthogonal to >>> resource types. >>> >>> Zhong Yu >>> >> > From zhong.j.yu at gmail.com Mon Jun 24 10:50:56 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Mon, 24 Jun 2013 12:50:56 -0500 Subject: Utilities of auto close In-Reply-To: <736415D1-F595-4F63-9E50-FA7EB1403A8A@gmail.com> References: <736415D1-F595-4F63-9E50-FA7EB1403A8A@gmail.com> Message-ID: On Mon, Jun 24, 2013 at 11:44 AM, Sam Pullara wrote: > The one thing that bothers me about this discussion is that TWR would have never existed if lambdas had been in the language ? it would just be a static method in java.io somewhere. It isn't clear to me that we should be mixing them at lambda body does not interact with local variables and control flow very well, it's not always a good replacement for dedicated control devices like for(...), TWR. all. It seems like we should be using something more like Jed's Managed suggestion or even less. > > For example, we could just add a .release() on the Stream (to make it clear that it is targeted at resource management) and have it called when either the stream is exhausted or an exception is thrown from the pipeline. For those that convert their streams to external iteration via .iterator() may the buyer beware. > > Sam > > On Jun 24, 2013, at 7:54 AM, Zhong Yu wrote: > >> I agree with you and Jeb that returning a wrapped Stream is better >> than returning a Stream that inherits Closeable. The wrapper is more >> generic, useful for all types of resources. But I think the task of >> triggering clean up should not be on individual resources, but rather >> on a enclosing lexical scope. I feel the latter pattern result in more >> pleasant code. For example >> >> try(Scope scope = Scope.newInstance()) >> { >> InputStream input = new FileInputStream(src); >> scope.onClose(input::close); >> >> OutputStream output = new FileOutputStream(dest); >> scope.onClose(output::close); >> >> ... >> } >> >> It's subjective, of course. >> >> Zhong Yu >> >> >> On Mon, Jun 24, 2013 at 6:35 AM, Samir Talwar wrote: >>> I don't like the idea of mutable scopes. This seems like it could introduce >>> a whole unnecessary class of bugs. I'd prefer to just replace the >>> inheritance with composition using your scope metaphor. >>> >>> try (IterableScope scope = Files.list(dir)) { >>> Stream entries = scope.stream(); >>> // do stuff with entries >>> } >>> >>> interface IterableScope extends Iterable, AutoCloseable { } >>> >>> The name is not so important, but the idea would be to separate the concepts >>> of iteration and scoping so that the user has to deal with them both, >>> instead of accidentally storing the CloseableStream as a Stream and >>> forgetting to close it. >>> >>> ? Samir. >>> >>> On 21 Jun 2013 15:48, "Zhong Yu" wrote: >>>> >>>> EG is discussing the issue of closing a Stream that ties to IO >>>> resources, and I'd like to throw in my 2 cents. >>>> >>>> Background: some new IO methods return Stream of things, for example >>>> >>>> class Files >>>> /** return a stream of entries in the dir */ >>>> static Stream list(Path dir); >>>> >>>> The problem is some IO resources are tied up and they need to be freed >>>> as soon as the Stream is no longer used. >>>> >>>> The current solution is >>>> >>>> interface CloseableStream extends Stream, AutoCloseable >>>> >>>> static CloseableStream list(Path dir); >>>> >>>> EG is discussing an alternative that makes all Streams AutoCloseable >>>> >>>> interface Stream extends AutoCloseable >>>> >>>> Some disagree with that approach, since most Streams do not need to be >>>> closed. >>>> >>>> == >>>> My proposal: >>>> >>>> It's better to move the business of close() away from Stream to some >>>> surrounding constructs. For example: >>>> >>>> try(Scope scope = Scope.newInstance()) >>>> { >>>> Stream entries = Files.list(scope, dir); >>>> } >>>> >>>> interface Scope extends AutoCloseable >>>> { >>>> void onClose(Runnable action); >>>> >>>> void close(); >>>> } >>>> >>>> static Stream list(Scope scope, Path dir) >>>> { >>>> ... >>>> scope.onClose( ()->{ free resources } ); >>>> ... >>>> } >>>> >>>> >>>> Scope provides generic destructor-like functionality, orthogonal to >>>> resource types. >>>> >>>> Zhong Yu >>>> >>> >> > From spullara at gmail.com Mon Jun 24 11:08:33 2013 From: spullara at gmail.com (Sam Pullara) Date: Mon, 24 Jun 2013 11:08:33 -0700 Subject: Utilities of auto close In-Reply-To: References: <736415D1-F595-4F63-9E50-FA7EB1403A8A@gmail.com> Message-ID: Not always, but in this case it is. My guess is that there will be a ton of methods like this in people's code that basically manage the lifecycle of objects ? it is one of the core use cases for lambdas. Sam On Jun 24, 2013, at 10:50 AM, Zhong Yu wrote: > On Mon, Jun 24, 2013 at 11:44 AM, Sam Pullara wrote: >> The one thing that bothers me about this discussion is that TWR would have never existed if lambdas had been in the language ? it would just be a static method in java.io somewhere. It isn't clear to me that we should be mixing them at > > lambda body does not interact with local variables and control flow > very well, it's not always a good replacement for dedicated control > devices like for(...), TWR. > > > > > all. It seems like we should be using something more like Jed's > Managed suggestion or even less. >> >> For example, we could just add a .release() on the Stream (to make it clear that it is targeted at resource management) and have it called when either the stream is exhausted or an exception is thrown from the pipeline. For those that convert their streams to external iteration via .iterator() may the buyer beware. >> >> Sam >> >> On Jun 24, 2013, at 7:54 AM, Zhong Yu wrote: >> >>> I agree with you and Jeb that returning a wrapped Stream is better >>> than returning a Stream that inherits Closeable. The wrapper is more >>> generic, useful for all types of resources. But I think the task of >>> triggering clean up should not be on individual resources, but rather >>> on a enclosing lexical scope. I feel the latter pattern result in more >>> pleasant code. For example >>> >>> try(Scope scope = Scope.newInstance()) >>> { >>> InputStream input = new FileInputStream(src); >>> scope.onClose(input::close); >>> >>> OutputStream output = new FileOutputStream(dest); >>> scope.onClose(output::close); >>> >>> ... >>> } >>> >>> It's subjective, of course. >>> >>> Zhong Yu >>> >>> >>> On Mon, Jun 24, 2013 at 6:35 AM, Samir Talwar wrote: >>>> I don't like the idea of mutable scopes. This seems like it could introduce >>>> a whole unnecessary class of bugs. I'd prefer to just replace the >>>> inheritance with composition using your scope metaphor. >>>> >>>> try (IterableScope scope = Files.list(dir)) { >>>> Stream entries = scope.stream(); >>>> // do stuff with entries >>>> } >>>> >>>> interface IterableScope extends Iterable, AutoCloseable { } >>>> >>>> The name is not so important, but the idea would be to separate the concepts >>>> of iteration and scoping so that the user has to deal with them both, >>>> instead of accidentally storing the CloseableStream as a Stream and >>>> forgetting to close it. >>>> >>>> ? Samir. >>>> >>>> On 21 Jun 2013 15:48, "Zhong Yu" wrote: >>>>> >>>>> EG is discussing the issue of closing a Stream that ties to IO >>>>> resources, and I'd like to throw in my 2 cents. >>>>> >>>>> Background: some new IO methods return Stream of things, for example >>>>> >>>>> class Files >>>>> /** return a stream of entries in the dir */ >>>>> static Stream list(Path dir); >>>>> >>>>> The problem is some IO resources are tied up and they need to be freed >>>>> as soon as the Stream is no longer used. >>>>> >>>>> The current solution is >>>>> >>>>> interface CloseableStream extends Stream, AutoCloseable >>>>> >>>>> static CloseableStream list(Path dir); >>>>> >>>>> EG is discussing an alternative that makes all Streams AutoCloseable >>>>> >>>>> interface Stream extends AutoCloseable >>>>> >>>>> Some disagree with that approach, since most Streams do not need to be >>>>> closed. >>>>> >>>>> == >>>>> My proposal: >>>>> >>>>> It's better to move the business of close() away from Stream to some >>>>> surrounding constructs. For example: >>>>> >>>>> try(Scope scope = Scope.newInstance()) >>>>> { >>>>> Stream entries = Files.list(scope, dir); >>>>> } >>>>> >>>>> interface Scope extends AutoCloseable >>>>> { >>>>> void onClose(Runnable action); >>>>> >>>>> void close(); >>>>> } >>>>> >>>>> static Stream list(Scope scope, Path dir) >>>>> { >>>>> ... >>>>> scope.onClose( ()->{ free resources } ); >>>>> ... >>>>> } >>>>> >>>>> >>>>> Scope provides generic destructor-like functionality, orthogonal to >>>>> resource types. >>>>> >>>>> Zhong Yu >>>>> >>>> >>> >> From jonathan.gibbons at oracle.com Mon Jun 24 15:46:42 2013 From: jonathan.gibbons at oracle.com (Jonathan Gibbons) Date: Mon, 24 Jun 2013 15:46:42 -0700 Subject: jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup In-Reply-To: <4DE1F43F-E144-4627-9021-069E2D5E465E@oracle.com> References: <4DE1F43F-E144-4627-9021-069E2D5E465E@oracle.com> Message-ID: <51C8CC52.4090607@oracle.com> Lambda-dev folk, What are the general expections of time and memory requirements for the streams tests? Gary has had to bump the time way up, and is now running out of memory. -- Jon On 06/24/2013 03:35 PM, Gary Collins wrote: > > > > jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup > jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java > > I bumped up the mem to 128mb and it still failed. > > Gary > > emb-sca-mv-plug-6281-3:/tmp# /export/local/common/jtreg/linux/bin/jtreg -verbose:all -timeout:25 -vmoptions:"-Xmx128m -Xms128m" -Xmx128m -jdk:/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java > Directory "JTwork" not found: creating > Directory "JTreport" not found: creating > -------------------------------------------------- > TEST: java/util/stream/boottest/java/util/stream/SpinedBufferTest.java > JDK under test: (/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt) > java version "1.8.0-ea" > Java(TM) SE Embedded Runtime Environment (build 1.8.0-ea-b91) > Java HotSpot(TM) Embedded Client VM (build 25.0-b33, mixed mode) > > > ACTION: build -- Passed. Build successful > REASON: Named class compiled on demand > TIME: 118.131 seconds > messages: > command: build java.util.stream.FlagOpTest java.util.stream.DoubleNodeTest java.util.stream.UnorderedTest java.util.stream.NodeTest java.util.stream.StreamOpFlagsTest java.util.stream.SpinedBufferTest java.util.stream.StreamFlagsTest java.util.stream.NodeBuilderTest java.util.stream.IntNodeTest java.util.stream.LongNodeTest java.util.stream.StreamReuseTest java.util.stream.OpTestCase java.util.stream.DoubleStreamTestDataProvider java.util.stream.DoubleStreamTestScenario java.util.stream.StreamTestScenario java.util.stream.StreamOpFlagTestHelper java.util.stream.IntermediateTestOp java.util.stream.SpliteratorTestHelper java.util.stream.LongStreamTestScenario java.util.stream.StatelessTestOp java.util.stream.TestFlagExpectedOp java.util.stream.StreamTestDataProvider java.util.stream.TestData java.util.stream.IntStreamTestDataProvider java.util.stream.StatefulTestOp java.util.stream.CollectorOps java.util.stream.IntStreamTestScenario java.util.stream.LambdaTestHelpers java.util.stream.LongStreamTestDataProvider java.util.stream.FlagDeclaringOp > reason: Named class compiled on demand > elapsed time (seconds): 118.131 > > ACTION: compile -- Passed. Compilation successful > REASON: .class file out of date or does not exist > TIME: 63.659 seconds > messages: > command: compile -XDignore.symbol.file=true -implicit:none /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java > reason: .class file out of date or does not exist > elapsed time (seconds): 63.659 > STDOUT: > STDERR: > > ACTION: compile -- Passed. Compilation successful > REASON: .class file out of date or does not exist > TIME: 54.331 seconds > messages: > command: compile -XDignore.symbol.file=true -implicit:none /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StatelessTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/FlagDeclaringOp.java > reason: .class file out of date or does not exist > elapsed time (seconds): 54.331 > STDOUT: > STDERR: > > ACTION: testng -- Failed. Execution failed: `main' threw exception: java.lang.OutOfMemoryError: Java heap space > REASON: Assumed action based on file name: run testng java.util.stream.SpinedBufferTest > TIME: 1814.868 seconds > messages: > command: testng java.util.stream.SpinedBufferTest > reason: Assumed action based on file name: run testng java.util.stream.SpinedBufferTest > elapsed time (seconds): 1814.868 > STDOUT: > [TestNG] Running: > java/util/stream/boottest/java/util/stream/SpinedBufferTest.java > > test public void java.util.stream.SpinedBufferTest.testDoubleSpinedBuffer(): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpinedBuffer(): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success > test public void java.util > > ... > Output overflow: > JT Harness has limited the test output to the text to that > at the beginning and the end, so that you can see how the > test began, and how it completed. > > If you need to see more of the output from the test, > set the system property javatest.maxOutputSize to a higher > value. The current value is 100000 > ... > > .testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpinedBuffer(): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success > test public void java.util.stream.SpinedBufferTest.testSpinedBuffer(): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success > > =============================================== > java/util/stream/boottest/java/util/stream/SpinedBufferTest.java > Total tests run: 928, Failures: 0, Skips: 0 > =============================================== > > STDERR: > java.lang.OutOfMemoryError: Java heap space > at java.util.Arrays.copyOf(Arrays.java:3002) > at java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:137) > at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:121) > at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:622) > at java.lang.StringBuilder.append(StringBuilder.java:202) > at org.testng.internal.Utils.escapeUnicode(Utils.java:567) > at org.testng.internal.Utils.writeUtf8File(Utils.java:115) > at org.testng.reporters.XMLReporter.generateReport(XMLReporter.java:66) > at org.testng.TestNG.generateReports(TestNG.java:1088) > at org.testng.TestNG.run(TestNG.java:1047) > at com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:155) > at com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:139) > at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) > at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) > at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) > at java.lang.reflect.Method.invoke(Method.java:491) > at com.sun.javatest.regtest.MainWrapper$MainThread.run(MainWrapper.java:94) > at java.lang.Thread.run(Thread.java:724) > > JavaTest Message: Test threw exception: java.lang.OutOfMemoryError: Java heap space > JavaTest Message: shutting down test > > STATUS:Failed.`main' threw exception: java.lang.OutOfMemoryError: Java heap space > > TEST RESULT: Failed. Execution failed: `main' threw exception: java.lang.OutOfMemoryError: Java heap space > -------------------------------------------------- > Test results: failed: 1 > > Report written to /tmp/JTreport/html/report.html > Results written to /tmp/JTwork > Error: Some tests failed or other problems occurred. > From brian.goetz at oracle.com Mon Jun 24 16:02:51 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Mon, 24 Jun 2013 19:02:51 -0400 Subject: jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup In-Reply-To: <51C8CC52.4090607@oracle.com> References: <4DE1F43F-E144-4627-9021-069E2D5E465E@oracle.com> <51C8CC52.4090607@oracle.com> Message-ID: <51C8D01B.1020008@oracle.com> On my server machine, the streams tests take about three minutes when run with -Xmx2500m. SpinedBufferTest is about 40s of that, so its definitely one of the heavier tests. (It is a pure unit test.) I think 3m for the tests of a significant package is entirely reasonable. On 6/24/2013 6:46 PM, Jonathan Gibbons wrote: > Lambda-dev folk, > > What are the general expections of time and memory requirements for the > streams tests? Gary has had to bump the time way up, and is now running > out of memory. > > -- Jon > > On 06/24/2013 03:35 PM, Gary Collins wrote: >> >> >> >> jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup >> jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> >> I bumped up the mem to 128mb and it still failed. >> >> Gary >> >> emb-sca-mv-plug-6281-3:/tmp# /export/local/common/jtreg/linux/bin/jtreg -verbose:all -timeout:25 -vmoptions:"-Xmx128m -Xms128m" -Xmx128m -jdk:/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> Directory "JTwork" not found: creating >> Directory "JTreport" not found: creating >> -------------------------------------------------- >> TEST: java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> JDK under test: (/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt) >> java version "1.8.0-ea" >> Java(TM) SE Embedded Runtime Environment (build 1.8.0-ea-b91) >> Java HotSpot(TM) Embedded Client VM (build 25.0-b33, mixed mode) >> >> >> ACTION: build -- Passed. Build successful >> REASON: Named class compiled on demand >> TIME: 118.131 seconds >> messages: >> command: build java.util.stream.FlagOpTest java.util.stream.DoubleNodeTest java.util.stream.UnorderedTest java.util.stream.NodeTest java.util.stream.StreamOpFlagsTest java.util.stream.SpinedBufferTest java.util.stream.StreamFlagsTest java.util.stream.NodeBuilderTest java.util.stream.IntNodeTest java.util.stream.LongNodeTest java.util.stream.StreamReuseTest java.util.stream.OpTestCase java.util.stream.DoubleStreamTestDataProvider java.util.stream.DoubleStreamTestScenario java.util.stream.StreamTestScenario java.util.stream.StreamOpFlagTestHelper java.util.stream.IntermediateTestOp java.util.stream.SpliteratorTestHelper java.util.stream.LongStreamTestScenario java.util.stream.StatelessTestOp java.util.stream.TestFlagExpectedOp java.util.stream.StreamTestDataProvider java.util.stream.TestData java.util.stream.IntStreamTestDataProvider java.util.stream.StatefulTestOp java.util.stream.CollectorOps java.util.stream.IntStreamTestScenario java.util.stream.LambdaTestHelpers java.u! t! > il.stream.LongStreamTestDataProvider java.util.stream.FlagDeclaringOp >> reason: Named class compiled on demand >> elapsed time (seconds): 118.131 >> >> ACTION: compile -- Passed. Compilation successful >> REASON: .class file out of date or does not exist >> TIME: 63.659 seconds >> messages: >> command: compile -XDignore.symbol.file=true -implicit:none /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java /export! /! > users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java >> reason: .class file out of date or does not exist >> elapsed time (seconds): 63.659 >> STDOUT: >> STDERR: >> >> ACTION: compile -- Passed. Compilation successful >> REASON: .class file out of date or does not exist >> TIME: 54.331 seconds >> messages: >> command: compile -XDignore.symbol.file=true -implicit:none /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boo! t! > lib/java/util/stream/StatelessTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataPr! ovi! > der.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot > lib/java/util/stream/FlagDeclaringOp.java >> reason: .class file out of date or does not exist >> elapsed time (seconds): 54.331 >> STDOUT: >> STDERR: >> >> ACTION: testng -- Failed. Execution failed: `main' threw exception: java.lang.OutOfMemoryError: Java heap space >> REASON: Assumed action based on file name: run testng java.util.stream.SpinedBufferTest >> TIME: 1814.868 seconds >> messages: >> command: testng java.util.stream.SpinedBufferTest >> reason: Assumed action based on file name: run testng java.util.stream.SpinedBufferTest >> elapsed time (seconds): 1814.868 >> STDOUT: >> [TestNG] Running: >> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> >> test public void java.util.stream.SpinedBufferTest.testDoubleSpinedBuffer(): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpinedBuffer(): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util >> >> ... >> Output overflow: >> JT Harness has limited the test output to the text to that >> at the beginning and the end, so that you can see how the >> test began, and how it completed. >> >> If you need to see more of the output from the test, >> set the system property javatest.maxOutputSize to a higher >> value. The current value is 100000 >> ... >> >> .testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpinedBuffer(): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testSpinedBuffer(): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> >> =============================================== >> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> Total tests run: 928, Failures: 0, Skips: 0 >> =============================================== >> >> STDERR: >> java.lang.OutOfMemoryError: Java heap space >> at java.util.Arrays.copyOf(Arrays.java:3002) >> at java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:137) >> at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:121) >> at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:622) >> at java.lang.StringBuilder.append(StringBuilder.java:202) >> at org.testng.internal.Utils.escapeUnicode(Utils.java:567) >> at org.testng.internal.Utils.writeUtf8File(Utils.java:115) >> at org.testng.reporters.XMLReporter.generateReport(XMLReporter.java:66) >> at org.testng.TestNG.generateReports(TestNG.java:1088) >> at org.testng.TestNG.run(TestNG.java:1047) >> at com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:155) >> at com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:139) >> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >> at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >> at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >> at java.lang.reflect.Method.invoke(Method.java:491) >> at com.sun.javatest.regtest.MainWrapper$MainThread.run(MainWrapper.java:94) >> at java.lang.Thread.run(Thread.java:724) >> >> JavaTest Message: Test threw exception: java.lang.OutOfMemoryError: Java heap space >> JavaTest Message: shutting down test >> >> STATUS:Failed.`main' threw exception: java.lang.OutOfMemoryError: Java heap space >> >> TEST RESULT: Failed. Execution failed: `main' threw exception: java.lang.OutOfMemoryError: Java heap space >> -------------------------------------------------- >> Test results: failed: 1 >> >> Report written to /tmp/JTreport/html/report.html >> Results written to /tmp/JTwork >> Error: Some tests failed or other problems occurred. >> > > > From jonathan.gibbons at oracle.com Mon Jun 24 16:48:20 2013 From: jonathan.gibbons at oracle.com (Jonathan Gibbons) Date: Mon, 24 Jun 2013 16:48:20 -0700 Subject: jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup In-Reply-To: <51C8D01B.1020008@oracle.com> References: <4DE1F43F-E144-4627-9021-069E2D5E465E@oracle.com> <51C8CC52.4090607@oracle.com> <51C8D01B.1020008@oracle.com> Message-ID: <51C8DAC4.1070903@oracle.com> Brian, What's your guideline for how long individual tests may take? We're just trying to sort out timeout values here. -- Jon On 06/24/2013 04:02 PM, Brian Goetz wrote: > On my server machine, the streams tests take about three minutes when > run with -Xmx2500m. SpinedBufferTest is about 40s of that, so its > definitely one of the heavier tests. (It is a pure unit test.) > > I think 3m for the tests of a significant package is entirely reasonable. > > On 6/24/2013 6:46 PM, Jonathan Gibbons wrote: >> Lambda-dev folk, >> >> What are the general expections of time and memory requirements for the >> streams tests? Gary has had to bump the time way up, and is now running >> out of memory. >> >> -- Jon >> >> On 06/24/2013 03:35 PM, Gary Collins wrote: >>> >>> >>> >>> jtreg test case I was talking about. I think its doing to much. >>> Might be a good candidate for breakup >>> jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>> >>> >>> I bumped up the mem to 128mb and it still failed. >>> >>> Gary >>> >>> emb-sca-mv-plug-6281-3:/tmp# >>> /export/local/common/jtreg/linux/bin/jtreg -verbose:all -timeout:25 >>> -vmoptions:"-Xmx128m -Xms128m" -Xmx128m >>> -jdk:/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>> Directory "JTwork" not found: creating >>> Directory "JTreport" not found: creating >>> -------------------------------------------------- >>> TEST: java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>> JDK under test: (/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt) >>> java version "1.8.0-ea" >>> Java(TM) SE Embedded Runtime Environment (build 1.8.0-ea-b91) >>> Java HotSpot(TM) Embedded Client VM (build 25.0-b33, mixed mode) >>> >>> >>> ACTION: build -- Passed. Build successful >>> REASON: Named class compiled on demand >>> TIME: 118.131 seconds >>> messages: >>> command: build java.util.stream.FlagOpTest >>> java.util.stream.DoubleNodeTest java.util.stream.UnorderedTest >>> java.util.stream.NodeTest java.util.stream.StreamOpFlagsTest >>> java.util.stream.SpinedBufferTest java.util.stream.StreamFlagsTest >>> java.util.stream.NodeBuilderTest java.util.stream.IntNodeTest >>> java.util.stream.LongNodeTest java.util.stream.StreamReuseTest >>> java.util.stream.OpTestCase >>> java.util.stream.DoubleStreamTestDataProvider >>> java.util.stream.DoubleStreamTestScenario >>> java.util.stream.StreamTestScenario >>> java.util.stream.StreamOpFlagTestHelper >>> java.util.stream.IntermediateTestOp >>> java.util.stream.SpliteratorTestHelper >>> java.util.stream.LongStreamTestScenario >>> java.util.stream.StatelessTestOp java.util.stream.TestFlagExpectedOp >>> java.util.stream.StreamTestDataProvider java.util.stream.TestData >>> java.util.stream.IntStreamTestDataProvider >>> java.util.stream.StatefulTestOp java.util.stream.CollectorOps >>> java.util.stream.IntStreamTestScenario >>> java.util.stream.LambdaTestHelpers java.ut! >> il.stream.LongStreamTestDataProvider java.util.stream.FlagDeclaringOp >>> reason: Named class compiled on demand >>> elapsed time (seconds): 118.131 >>> >>> ACTION: compile -- Passed. Compilation successful >>> REASON: .class file out of date or does not exist >>> TIME: 63.659 seconds >>> messages: >>> command: compile -XDignore.symbol.file=true -implicit:none >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java >>> /export/! >> users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java >> >>> reason: .class file out of date or does not exist >>> elapsed time (seconds): 63.659 >>> STDOUT: >>> STDERR: >>> >>> ACTION: compile -- Passed. Compilation successful >>> REASON: .class file out of date or does not exist >>> TIME: 54.331 seconds >>> messages: >>> command: compile -XDignore.symbol.file=true -implicit:none >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot! >> lib/java/util/stream/StatelessTestOp.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java >> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvi! >> >> der.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot >> lib/java/util/stream/FlagDeclaringOp.java >>> reason: .class file out of date or does not exist >>> elapsed time (seconds): 54.331 >>> STDOUT: >>> STDERR: >>> >>> ACTION: testng -- Failed. Execution failed: `main' threw exception: >>> java.lang.OutOfMemoryError: Java heap space >>> REASON: Assumed action based on file name: run testng >>> java.util.stream.SpinedBufferTest >>> TIME: 1814.868 seconds >>> messages: >>> command: testng java.util.stream.SpinedBufferTest >>> reason: Assumed action based on file name: run testng >>> java.util.stream.SpinedBufferTest >>> elapsed time (seconds): 1814.868 >>> STDOUT: >>> [TestNG] Running: >>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>> >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpinedBuffer(): success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpinedBuffer(): success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void java.util >>> >>> ... >>> Output overflow: >>> JT Harness has limited the test output to the text to that >>> at the beginning and the end, so that you can see how the >>> test began, and how it completed. >>> >>> If you need to see more of the output from the test, >>> set the system property javatest.maxOutputSize to a higher >>> value. The current value is 100000 >>> ... >>> >>> .testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpinedBuffer(): success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpinedBuffer(): success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> test public void >>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>> success >>> >>> =============================================== >>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>> Total tests run: 928, Failures: 0, Skips: 0 >>> =============================================== >>> >>> STDERR: >>> java.lang.OutOfMemoryError: Java heap space >>> at java.util.Arrays.copyOf(Arrays.java:3002) >>> at >>> java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:137) >>> at >>> java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:121) >>> at >>> java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:622) >>> at java.lang.StringBuilder.append(StringBuilder.java:202) >>> at org.testng.internal.Utils.escapeUnicode(Utils.java:567) >>> at org.testng.internal.Utils.writeUtf8File(Utils.java:115) >>> at >>> org.testng.reporters.XMLReporter.generateReport(XMLReporter.java:66) >>> at org.testng.TestNG.generateReports(TestNG.java:1088) >>> at org.testng.TestNG.run(TestNG.java:1047) >>> at >>> com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:155) >>> at >>> com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:139) >>> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >>> at >>> sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >>> at >>> sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >>> at java.lang.reflect.Method.invoke(Method.java:491) >>> at >>> com.sun.javatest.regtest.MainWrapper$MainThread.run(MainWrapper.java:94) >>> >>> at java.lang.Thread.run(Thread.java:724) >>> >>> JavaTest Message: Test threw exception: java.lang.OutOfMemoryError: >>> Java heap space >>> JavaTest Message: shutting down test >>> >>> STATUS:Failed.`main' threw exception: java.lang.OutOfMemoryError: >>> Java heap space >>> >>> TEST RESULT: Failed. Execution failed: `main' threw exception: >>> java.lang.OutOfMemoryError: Java heap space >>> -------------------------------------------------- >>> Test results: failed: 1 >>> >>> Report written to /tmp/JTreport/html/report.html >>> Results written to /tmp/JTwork >>> Error: Some tests failed or other problems occurred. >>> >> >> >> From brian.goetz at oracle.com Mon Jun 24 17:37:47 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Mon, 24 Jun 2013 20:37:47 -0400 Subject: jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup In-Reply-To: <51C8DAC4.1070903@oracle.com> References: <4DE1F43F-E144-4627-9021-069E2D5E465E@oracle.com> <51C8CC52.4090607@oracle.com> <51C8D01B.1020008@oracle.com> <51C8DAC4.1070903@oracle.com> Message-ID: <51C8E65B.5000204@oracle.com> We typically try and cap it at 30-45s on a reasonable machine. (And reasonable is quite reasonable; my server system cost about $1000 to build.) Since our whole java.util.stream test suite runs in 3m, we only have a few of those. On 6/24/2013 7:48 PM, Jonathan Gibbons wrote: > Brian, > > What's your guideline for how long individual tests may take? We're just > trying to sort out timeout values here. > > -- Jon > > > On 06/24/2013 04:02 PM, Brian Goetz wrote: >> On my server machine, the streams tests take about three minutes when >> run with -Xmx2500m. SpinedBufferTest is about 40s of that, so its >> definitely one of the heavier tests. (It is a pure unit test.) >> >> I think 3m for the tests of a significant package is entirely reasonable. >> >> On 6/24/2013 6:46 PM, Jonathan Gibbons wrote: >>> Lambda-dev folk, >>> >>> What are the general expections of time and memory requirements for the >>> streams tests? Gary has had to bump the time way up, and is now running >>> out of memory. >>> >>> -- Jon >>> >>> On 06/24/2013 03:35 PM, Gary Collins wrote: >>>> >>>> >>>> >>>> jtreg test case I was talking about. I think its doing to much. >>>> Might be a good candidate for breakup >>>> jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> >>>> >>>> I bumped up the mem to 128mb and it still failed. >>>> >>>> Gary >>>> >>>> emb-sca-mv-plug-6281-3:/tmp# >>>> /export/local/common/jtreg/linux/bin/jtreg -verbose:all -timeout:25 >>>> -vmoptions:"-Xmx128m -Xms128m" -Xmx128m >>>> -jdk:/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> >>>> Directory "JTwork" not found: creating >>>> Directory "JTreport" not found: creating >>>> -------------------------------------------------- >>>> TEST: java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> JDK under test: (/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt) >>>> java version "1.8.0-ea" >>>> Java(TM) SE Embedded Runtime Environment (build 1.8.0-ea-b91) >>>> Java HotSpot(TM) Embedded Client VM (build 25.0-b33, mixed mode) >>>> >>>> >>>> ACTION: build -- Passed. Build successful >>>> REASON: Named class compiled on demand >>>> TIME: 118.131 seconds >>>> messages: >>>> command: build java.util.stream.FlagOpTest >>>> java.util.stream.DoubleNodeTest java.util.stream.UnorderedTest >>>> java.util.stream.NodeTest java.util.stream.StreamOpFlagsTest >>>> java.util.stream.SpinedBufferTest java.util.stream.StreamFlagsTest >>>> java.util.stream.NodeBuilderTest java.util.stream.IntNodeTest >>>> java.util.stream.LongNodeTest java.util.stream.StreamReuseTest >>>> java.util.stream.OpTestCase >>>> java.util.stream.DoubleStreamTestDataProvider >>>> java.util.stream.DoubleStreamTestScenario >>>> java.util.stream.StreamTestScenario >>>> java.util.stream.StreamOpFlagTestHelper >>>> java.util.stream.IntermediateTestOp >>>> java.util.stream.SpliteratorTestHelper >>>> java.util.stream.LongStreamTestScenario >>>> java.util.stream.StatelessTestOp java.util.stream.TestFlagExpectedOp >>>> java.util.stream.StreamTestDataProvider java.util.stream.TestData >>>> java.util.stream.IntStreamTestDataProvider >>>> java.util.stream.StatefulTestOp java.util.stream.CollectorOps >>>> java.util.stream.IntStreamTestScenario >>>> java.util.stream.LambdaTestHelpers java.ut! >>> il.stream.LongStreamTestDataProvider java.util.stream.FlagDeclaringOp >>>> reason: Named class compiled on demand >>>> elapsed time (seconds): 118.131 >>>> >>>> ACTION: compile -- Passed. Compilation successful >>>> REASON: .class file out of date or does not exist >>>> TIME: 63.659 seconds >>>> messages: >>>> command: compile -XDignore.symbol.file=true -implicit:none >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java >>>> /export/! >>> users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java >>> >>>> reason: .class file out of date or does not exist >>>> elapsed time (seconds): 63.659 >>>> STDOUT: >>>> STDERR: >>>> >>>> ACTION: compile -- Passed. Compilation successful >>>> REASON: .class file out of date or does not exist >>>> TIME: 54.331 seconds >>>> messages: >>>> command: compile -XDignore.symbol.file=true -implicit:none >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot! >>> lib/java/util/stream/StatelessTestOp.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvi! >>> >>> der.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot >>> lib/java/util/stream/FlagDeclaringOp.java >>>> reason: .class file out of date or does not exist >>>> elapsed time (seconds): 54.331 >>>> STDOUT: >>>> STDERR: >>>> >>>> ACTION: testng -- Failed. Execution failed: `main' threw exception: >>>> java.lang.OutOfMemoryError: Java heap space >>>> REASON: Assumed action based on file name: run testng >>>> java.util.stream.SpinedBufferTest >>>> TIME: 1814.868 seconds >>>> messages: >>>> command: testng java.util.stream.SpinedBufferTest >>>> reason: Assumed action based on file name: run testng >>>> java.util.stream.SpinedBufferTest >>>> elapsed time (seconds): 1814.868 >>>> STDOUT: >>>> [TestNG] Running: >>>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpinedBuffer(): success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpinedBuffer(): success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void java.util >>>> >>>> ... >>>> Output overflow: >>>> JT Harness has limited the test output to the text to that >>>> at the beginning and the end, so that you can see how the >>>> test began, and how it completed. >>>> >>>> If you need to see more of the output from the test, >>>> set the system property javatest.maxOutputSize to a higher >>>> value. The current value is 100000 >>>> ... >>>> >>>> .testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpinedBuffer(): success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpinedBuffer(): success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> >>>> =============================================== >>>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> Total tests run: 928, Failures: 0, Skips: 0 >>>> =============================================== >>>> >>>> STDERR: >>>> java.lang.OutOfMemoryError: Java heap space >>>> at java.util.Arrays.copyOf(Arrays.java:3002) >>>> at >>>> java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:137) >>>> >>>> at >>>> java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:121) >>>> >>>> at >>>> java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:622) >>>> at java.lang.StringBuilder.append(StringBuilder.java:202) >>>> at org.testng.internal.Utils.escapeUnicode(Utils.java:567) >>>> at org.testng.internal.Utils.writeUtf8File(Utils.java:115) >>>> at >>>> org.testng.reporters.XMLReporter.generateReport(XMLReporter.java:66) >>>> at org.testng.TestNG.generateReports(TestNG.java:1088) >>>> at org.testng.TestNG.run(TestNG.java:1047) >>>> at >>>> com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:155) >>>> >>>> at >>>> com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:139) >>>> >>>> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >>>> at >>>> sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >>>> >>>> at >>>> sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >>>> >>>> at java.lang.reflect.Method.invoke(Method.java:491) >>>> at >>>> com.sun.javatest.regtest.MainWrapper$MainThread.run(MainWrapper.java:94) >>>> >>>> at java.lang.Thread.run(Thread.java:724) >>>> >>>> JavaTest Message: Test threw exception: java.lang.OutOfMemoryError: >>>> Java heap space >>>> JavaTest Message: shutting down test >>>> >>>> STATUS:Failed.`main' threw exception: java.lang.OutOfMemoryError: >>>> Java heap space >>>> >>>> TEST RESULT: Failed. Execution failed: `main' threw exception: >>>> java.lang.OutOfMemoryError: Java heap space >>>> -------------------------------------------------- >>>> Test results: failed: 1 >>>> >>>> Report written to /tmp/JTreport/html/report.html >>>> Results written to /tmp/JTwork >>>> Error: Some tests failed or other problems occurred. >>>> >>> >>> >>> > From jonathan.gibbons at oracle.com Mon Jun 24 17:39:16 2013 From: jonathan.gibbons at oracle.com (Jonathan Gibbons) Date: Mon, 24 Jun 2013 17:39:16 -0700 Subject: jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup In-Reply-To: <51C8E65B.5000204@oracle.com> References: <4DE1F43F-E144-4627-9021-069E2D5E465E@oracle.com> <51C8CC52.4090607@oracle.com> <51C8D01B.1020008@oracle.com> <51C8DAC4.1070903@oracle.com> <51C8E65B.5000204@oracle.com> Message-ID: <51C8E6B4.6020409@oracle.com> That sounds good; thanks for the info. -- Jon On 06/24/2013 05:37 PM, Brian Goetz wrote: > We typically try and cap it at 30-45s on a reasonable machine. (And > reasonable is quite reasonable; my server system cost about $1000 to > build.) Since our whole java.util.stream test suite runs in 3m, we > only have a few of those. > > On 6/24/2013 7:48 PM, Jonathan Gibbons wrote: >> Brian, >> >> What's your guideline for how long individual tests may take? We're just >> trying to sort out timeout values here. >> >> -- Jon >> >> >> On 06/24/2013 04:02 PM, Brian Goetz wrote: >>> On my server machine, the streams tests take about three minutes when >>> run with -Xmx2500m. SpinedBufferTest is about 40s of that, so its >>> definitely one of the heavier tests. (It is a pure unit test.) >>> >>> I think 3m for the tests of a significant package is entirely >>> reasonable. >>> >>> On 6/24/2013 6:46 PM, Jonathan Gibbons wrote: >>>> Lambda-dev folk, >>>> >>>> What are the general expections of time and memory requirements for >>>> the >>>> streams tests? Gary has had to bump the time way up, and is now >>>> running >>>> out of memory. >>>> >>>> -- Jon >>>> >>>> On 06/24/2013 03:35 PM, Gary Collins wrote: >>>>> >>>>> >>>>> >>>>> jtreg test case I was talking about. I think its doing to much. >>>>> Might be a good candidate for breakup >>>>> jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>>> >>>>> >>>>> >>>>> I bumped up the mem to 128mb and it still failed. >>>>> >>>>> Gary >>>>> >>>>> emb-sca-mv-plug-6281-3:/tmp# >>>>> /export/local/common/jtreg/linux/bin/jtreg -verbose:all -timeout:25 >>>>> -vmoptions:"-Xmx128m -Xms128m" -Xmx128m >>>>> -jdk:/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>>> >>>>> >>>>> Directory "JTwork" not found: creating >>>>> Directory "JTreport" not found: creating >>>>> -------------------------------------------------- >>>>> TEST: >>>>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>>> JDK under test: (/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt) >>>>> java version "1.8.0-ea" >>>>> Java(TM) SE Embedded Runtime Environment (build 1.8.0-ea-b91) >>>>> Java HotSpot(TM) Embedded Client VM (build 25.0-b33, mixed mode) >>>>> >>>>> >>>>> ACTION: build -- Passed. Build successful >>>>> REASON: Named class compiled on demand >>>>> TIME: 118.131 seconds >>>>> messages: >>>>> command: build java.util.stream.FlagOpTest >>>>> java.util.stream.DoubleNodeTest java.util.stream.UnorderedTest >>>>> java.util.stream.NodeTest java.util.stream.StreamOpFlagsTest >>>>> java.util.stream.SpinedBufferTest java.util.stream.StreamFlagsTest >>>>> java.util.stream.NodeBuilderTest java.util.stream.IntNodeTest >>>>> java.util.stream.LongNodeTest java.util.stream.StreamReuseTest >>>>> java.util.stream.OpTestCase >>>>> java.util.stream.DoubleStreamTestDataProvider >>>>> java.util.stream.DoubleStreamTestScenario >>>>> java.util.stream.StreamTestScenario >>>>> java.util.stream.StreamOpFlagTestHelper >>>>> java.util.stream.IntermediateTestOp >>>>> java.util.stream.SpliteratorTestHelper >>>>> java.util.stream.LongStreamTestScenario >>>>> java.util.stream.StatelessTestOp java.util.stream.TestFlagExpectedOp >>>>> java.util.stream.StreamTestDataProvider java.util.stream.TestData >>>>> java.util.stream.IntStreamTestDataProvider >>>>> java.util.stream.StatefulTestOp java.util.stream.CollectorOps >>>>> java.util.stream.IntStreamTestScenario >>>>> java.util.stream.LambdaTestHelpers java.ut! >>>> il.stream.LongStreamTestDataProvider >>>> java.util.stream.FlagDeclaringOp >>>>> reason: Named class compiled on demand >>>>> elapsed time (seconds): 118.131 >>>>> >>>>> ACTION: compile -- Passed. Compilation successful >>>>> REASON: .class file out of date or does not exist >>>>> TIME: 63.659 seconds >>>>> messages: >>>>> command: compile -XDignore.symbol.file=true -implicit:none >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java >>>>> >>>>> /export/! >>>> users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java >>>> >>>> >>>>> reason: .class file out of date or does not exist >>>>> elapsed time (seconds): 63.659 >>>>> STDOUT: >>>>> STDERR: >>>>> >>>>> ACTION: compile -- Passed. Compilation successful >>>>> REASON: .class file out of date or does not exist >>>>> TIME: 54.331 seconds >>>>> messages: >>>>> command: compile -XDignore.symbol.file=true -implicit:none >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java >>>>> >>>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot! >>>> lib/java/util/stream/StatelessTestOp.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java >>>> >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvi! >>>> >>>> >>>> der.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot >>>> lib/java/util/stream/FlagDeclaringOp.java >>>>> reason: .class file out of date or does not exist >>>>> elapsed time (seconds): 54.331 >>>>> STDOUT: >>>>> STDERR: >>>>> >>>>> ACTION: testng -- Failed. Execution failed: `main' threw exception: >>>>> java.lang.OutOfMemoryError: Java heap space >>>>> REASON: Assumed action based on file name: run testng >>>>> java.util.stream.SpinedBufferTest >>>>> TIME: 1814.868 seconds >>>>> messages: >>>>> command: testng java.util.stream.SpinedBufferTest >>>>> reason: Assumed action based on file name: run testng >>>>> java.util.stream.SpinedBufferTest >>>>> elapsed time (seconds): 1814.868 >>>>> STDOUT: >>>>> [TestNG] Running: >>>>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>>> >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpinedBuffer(): success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpinedBuffer(): success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void java.util >>>>> >>>>> ... >>>>> Output overflow: >>>>> JT Harness has limited the test output to the text to that >>>>> at the beginning and the end, so that you can see how the >>>>> test began, and how it completed. >>>>> >>>>> If you need to see more of the output from the test, >>>>> set the system property javatest.maxOutputSize to a higher >>>>> value. The current value is 100000 >>>>> ... >>>>> >>>>> .testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpinedBuffer(): success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpinedBuffer(): success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> test public void >>>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>>> >>>>> success >>>>> >>>>> =============================================== >>>>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>>> Total tests run: 928, Failures: 0, Skips: 0 >>>>> =============================================== >>>>> >>>>> STDERR: >>>>> java.lang.OutOfMemoryError: Java heap space >>>>> at java.util.Arrays.copyOf(Arrays.java:3002) >>>>> at >>>>> java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:137) >>>>> >>>>> >>>>> at >>>>> java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:121) >>>>> >>>>> >>>>> at >>>>> java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:622) >>>>> >>>>> at java.lang.StringBuilder.append(StringBuilder.java:202) >>>>> at org.testng.internal.Utils.escapeUnicode(Utils.java:567) >>>>> at org.testng.internal.Utils.writeUtf8File(Utils.java:115) >>>>> at >>>>> org.testng.reporters.XMLReporter.generateReport(XMLReporter.java:66) >>>>> at org.testng.TestNG.generateReports(TestNG.java:1088) >>>>> at org.testng.TestNG.run(TestNG.java:1047) >>>>> at >>>>> com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:155) >>>>> >>>>> >>>>> at >>>>> com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:139) >>>>> >>>>> >>>>> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >>>>> at >>>>> sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >>>>> >>>>> >>>>> at >>>>> sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >>>>> >>>>> >>>>> at java.lang.reflect.Method.invoke(Method.java:491) >>>>> at >>>>> com.sun.javatest.regtest.MainWrapper$MainThread.run(MainWrapper.java:94) >>>>> >>>>> >>>>> at java.lang.Thread.run(Thread.java:724) >>>>> >>>>> JavaTest Message: Test threw exception: java.lang.OutOfMemoryError: >>>>> Java heap space >>>>> JavaTest Message: shutting down test >>>>> >>>>> STATUS:Failed.`main' threw exception: java.lang.OutOfMemoryError: >>>>> Java heap space >>>>> >>>>> TEST RESULT: Failed. Execution failed: `main' threw exception: >>>>> java.lang.OutOfMemoryError: Java heap space >>>>> -------------------------------------------------- >>>>> Test results: failed: 1 >>>>> >>>>> Report written to /tmp/JTreport/html/report.html >>>>> Results written to /tmp/JTwork >>>>> Error: Some tests failed or other problems occurred. >>>>> >>>> >>>> >>>> >> From mike.duigou at oracle.com Mon Jun 24 21:36:20 2013 From: mike.duigou at oracle.com (Mike Duigou) Date: Mon, 24 Jun 2013 22:36:20 -0600 Subject: jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup In-Reply-To: <51C8DAC4.1070903@oracle.com> References: <4DE1F43F-E144-4627-9021-069E2D5E465E@oracle.com> <51C8CC52.4090607@oracle.com> <51C8D01B.1020008@oracle.com> <51C8DAC4.1070903@oracle.com> Message-ID: Is the plan to use the timeout multiplier or an absolute timeout? I would recommend against absolute timeouts if we can find a way to make multipliers work for this case. Mike On Jun 24 2013, at 17:48 , Jonathan Gibbons wrote: > Brian, > > What's your guideline for how long individual tests may take? We're just > trying to sort out timeout values here. > > -- Jon > > > On 06/24/2013 04:02 PM, Brian Goetz wrote: >> On my server machine, the streams tests take about three minutes when >> run with -Xmx2500m. SpinedBufferTest is about 40s of that, so its >> definitely one of the heavier tests. (It is a pure unit test.) >> >> I think 3m for the tests of a significant package is entirely reasonable. >> >> On 6/24/2013 6:46 PM, Jonathan Gibbons wrote: >>> Lambda-dev folk, >>> >>> What are the general expections of time and memory requirements for the >>> streams tests? Gary has had to bump the time way up, and is now running >>> out of memory. >>> >>> -- Jon >>> >>> On 06/24/2013 03:35 PM, Gary Collins wrote: >>>> >>>> >>>> >>>> jtreg test case I was talking about. I think its doing to much. >>>> Might be a good candidate for breakup >>>> jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> >>>> >>>> I bumped up the mem to 128mb and it still failed. >>>> >>>> Gary >>>> >>>> emb-sca-mv-plug-6281-3:/tmp# >>>> /export/local/common/jtreg/linux/bin/jtreg -verbose:all -timeout:25 >>>> -vmoptions:"-Xmx128m -Xms128m" -Xmx128m >>>> -jdk:/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> Directory "JTwork" not found: creating >>>> Directory "JTreport" not found: creating >>>> -------------------------------------------------- >>>> TEST: java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> JDK under test: (/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt) >>>> java version "1.8.0-ea" >>>> Java(TM) SE Embedded Runtime Environment (build 1.8.0-ea-b91) >>>> Java HotSpot(TM) Embedded Client VM (build 25.0-b33, mixed mode) >>>> >>>> >>>> ACTION: build -- Passed. Build successful >>>> REASON: Named class compiled on demand >>>> TIME: 118.131 seconds >>>> messages: >>>> command: build java.util.stream.FlagOpTest >>>> java.util.stream.DoubleNodeTest java.util.stream.UnorderedTest >>>> java.util.stream.NodeTest java.util.stream.StreamOpFlagsTest >>>> java.util.stream.SpinedBufferTest java.util.stream.StreamFlagsTest >>>> java.util.stream.NodeBuilderTest java.util.stream.IntNodeTest >>>> java.util.stream.LongNodeTest java.util.stream.StreamReuseTest >>>> java.util.stream.OpTestCase >>>> java.util.stream.DoubleStreamTestDataProvider >>>> java.util.stream.DoubleStreamTestScenario >>>> java.util.stream.StreamTestScenario >>>> java.util.stream.StreamOpFlagTestHelper >>>> java.util.stream.IntermediateTestOp >>>> java.util.stream.SpliteratorTestHelper >>>> java.util.stream.LongStreamTestScenario >>>> java.util.stream.StatelessTestOp java.util.stream.TestFlagExpectedOp >>>> java.util.stream.StreamTestDataProvider java.util.stream.TestData >>>> java.util.stream.IntStreamTestDataProvider >>>> java.util.stream.StatefulTestOp java.util.stream.CollectorOps >>>> java.util.stream.IntStreamTestScenario >>>> java.util.stream.LambdaTestHelpers java.ut! >>> il.stream.LongStreamTestDataProvider java.util.stream.FlagDeclaringOp >>>> reason: Named class compiled on demand >>>> elapsed time (seconds): 118.131 >>>> >>>> ACTION: compile -- Passed. Compilation successful >>>> REASON: .class file out of date or does not exist >>>> TIME: 63.659 seconds >>>> messages: >>>> command: compile -XDignore.symbol.file=true -implicit:none >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java >>>> /export/! >>> users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java >>> >>>> reason: .class file out of date or does not exist >>>> elapsed time (seconds): 63.659 >>>> STDOUT: >>>> STDERR: >>>> >>>> ACTION: compile -- Passed. Compilation successful >>>> REASON: .class file out of date or does not exist >>>> TIME: 54.331 seconds >>>> messages: >>>> command: compile -XDignore.symbol.file=true -implicit:none >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java >>>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot! >>> lib/java/util/stream/StatelessTestOp.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java >>> /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvi! >>> >>> der.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot >>> lib/java/util/stream/FlagDeclaringOp.java >>>> reason: .class file out of date or does not exist >>>> elapsed time (seconds): 54.331 >>>> STDOUT: >>>> STDERR: >>>> >>>> ACTION: testng -- Failed. Execution failed: `main' threw exception: >>>> java.lang.OutOfMemoryError: Java heap space >>>> REASON: Assumed action based on file name: run testng >>>> java.util.stream.SpinedBufferTest >>>> TIME: 1814.868 seconds >>>> messages: >>>> command: testng java.util.stream.SpinedBufferTest >>>> reason: Assumed action based on file name: run testng >>>> java.util.stream.SpinedBufferTest >>>> elapsed time (seconds): 1814.868 >>>> STDOUT: >>>> [TestNG] Running: >>>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpinedBuffer(): success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpinedBuffer(): success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void java.util >>>> >>>> ... >>>> Output overflow: >>>> JT Harness has limited the test output to the text to that >>>> at the beginning and the end, so that you can see how the >>>> test began, and how it completed. >>>> >>>> If you need to see more of the output from the test, >>>> set the system property javatest.maxOutputSize to a higher >>>> value. The current value is 100000 >>>> ... >>>> >>>> .testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpinedBuffer(): success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpinedBuffer(): success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> test public void >>>> java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): >>>> success >>>> >>>> =============================================== >>>> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >>>> Total tests run: 928, Failures: 0, Skips: 0 >>>> =============================================== >>>> >>>> STDERR: >>>> java.lang.OutOfMemoryError: Java heap space >>>> at java.util.Arrays.copyOf(Arrays.java:3002) >>>> at >>>> java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:137) >>>> at >>>> java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:121) >>>> at >>>> java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:622) >>>> at java.lang.StringBuilder.append(StringBuilder.java:202) >>>> at org.testng.internal.Utils.escapeUnicode(Utils.java:567) >>>> at org.testng.internal.Utils.writeUtf8File(Utils.java:115) >>>> at >>>> org.testng.reporters.XMLReporter.generateReport(XMLReporter.java:66) >>>> at org.testng.TestNG.generateReports(TestNG.java:1088) >>>> at org.testng.TestNG.run(TestNG.java:1047) >>>> at >>>> com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:155) >>>> at >>>> com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:139) >>>> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >>>> at >>>> sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >>>> at >>>> sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >>>> at java.lang.reflect.Method.invoke(Method.java:491) >>>> at >>>> com.sun.javatest.regtest.MainWrapper$MainThread.run(MainWrapper.java:94) >>>> >>>> at java.lang.Thread.run(Thread.java:724) >>>> >>>> JavaTest Message: Test threw exception: java.lang.OutOfMemoryError: >>>> Java heap space >>>> JavaTest Message: shutting down test >>>> >>>> STATUS:Failed.`main' threw exception: java.lang.OutOfMemoryError: >>>> Java heap space >>>> >>>> TEST RESULT: Failed. Execution failed: `main' threw exception: >>>> java.lang.OutOfMemoryError: Java heap space >>>> -------------------------------------------------- >>>> Test results: failed: 1 >>>> >>>> Report written to /tmp/JTreport/html/report.html >>>> Results written to /tmp/JTwork >>>> Error: Some tests failed or other problems occurred. >>>> >>> >>> >>> > > From peter.levart at gmail.com Tue Jun 25 02:21:51 2013 From: peter.levart at gmail.com (Peter Levart) Date: Tue, 25 Jun 2013 11:21:51 +0200 Subject: hg: lambda/lambda/jdk: Override reverse() for NullComparator In-Reply-To: <20130510064801.0B5B0489A0@hg.openjdk.java.net> References: <20130510064801.0B5B0489A0@hg.openjdk.java.net> Message-ID: <51C9612F.8030407@gmail.com> Hi Henry, I think there's also a possibility to override Collections.ReverseComparator.reversed(), like that: @Override public Comparator> reversed() { return Comparator.naturalOrder(); } More complete solution would be to add an if statement in Collections.reverseOrder(Comparator): public static Comparator reverseOrder(Comparator cmp) { ... if (cmp == ReverseComparator.REVERSE_ORDER) return (Comparator) Comparators.NaturalOrderComparator.INSTANCE; ... } But that could make code compiled with JDK7 and only run on JDK8 produce serialized streams that are not compatible with JDK7. Overriding just the ReverseComparator.reversed() method only affects code that is compiled on JDK8, since this is new method. Regards, Peter On 05/10/2013 08:47 AM, henry.jen at oracle.com wrote: > Changeset: 6d9e66f573f6 > Author: henryjen > Date: 2013-05-09 23:47 -0700 > URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6d9e66f573f6 > > Override reverse() for NullComparator > > ! src/share/classes/java/util/Comparators.java > ! test/java/util/Comparator/BasicTest.java > > From paul.sandoz at oracle.com Tue Jun 25 07:30:00 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Tue, 25 Jun 2013 14:30:00 +0000 Subject: hg: lambda/lambda/jdk: Typo. Message-ID: <20130625143012.D2C2D484ED@hg.openjdk.java.net> Changeset: 2b3b4f067ebe Author: psandoz Date: 2013-06-25 16:29 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/2b3b4f067ebe Typo. Contributed-by: Chris Hegarty ! src/share/classes/java/util/stream/package-info.java From paul.sandoz at oracle.com Tue Jun 25 07:25:52 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Tue, 25 Jun 2013 14:25:52 +0000 Subject: hg: lambda/lambda/jdk: 3 new changesets Message-ID: <20130625142642.72908484EB@hg.openjdk.java.net> Changeset: 2029f6c93b17 Author: psandoz Date: 2013-06-21 11:29 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/2029f6c93b17 Fix license headers. ! src/share/classes/java/util/concurrent/CountedCompleter.java ! src/share/classes/java/util/concurrent/ForkJoinPool.java ! src/share/classes/java/util/concurrent/ForkJoinTask.java ! src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java Changeset: 93a086ba83ff Author: psandoz Date: 2013-06-25 16:23 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/93a086ba83ff Tests for array parallel prefix and set all. Contributed-by: Tristan Yan + test/java/util/Arrays/ParallelPrefix.java + test/java/util/Arrays/ParallelSet.java Changeset: dc076723aea3 Author: psandoz Date: 2013-06-25 16:25 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/dc076723aea3 Merge. From paul.sandoz at oracle.com Tue Jun 25 09:58:35 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Tue, 25 Jun 2013 18:58:35 +0200 Subject: jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup In-Reply-To: <51C8CC52.4090607@oracle.com> References: <4DE1F43F-E144-4627-9021-069E2D5E465E@oracle.com> <51C8CC52.4090607@oracle.com> Message-ID: <54C54D1C-EB1D-472B-9F95-5908D0820F54@oracle.com> On Jun 25, 2013, at 12:46 AM, Jonathan Gibbons wrote: > Lambda-dev folk, > > What are the general expections of time and memory requirements for the > streams tests? Gary has had to bump the time way up, and is now running > out of memory. > Did that take nearly 4 minutes to build and compile the test code? it takes about 15s on my Mac to build/compile and 22s to execute the tests, and that's with the same jtreg argument as below. That memory issue could be related to generating the reports, since the OOM stack trace is related to that, and i presume all memory associated with execution of tests would have been cleaned up. However, the parameter data is reported as part of the XML output. That could easily be fixed by using a Supplier of a buffer. Not quite sure what to do about the time taken, it seems like an extremely underpowered machine is being utilised. Paul. $ jtreg -verbose:all -timeout:25 -vmoptions:"-Xmx128m -Xms128m" -Xmx128m -jdk:/Users/sandoz/Projects/jdk8/lambda/build/macosx-x86_64-normal-server-release/jdk/ java/util/stream/boottest/java/util/stream/SpinedBufferTest.java Directory "JTwork" not found: creating Directory "JTreport" not found: creating -------------------------------------------------- TEST: java/util/stream/boottest/java/util/stream/SpinedBufferTest.java JDK under test: (/Users/sandoz/Projects/jdk8/lambda/build/macosx-x86_64-normal-server-release/jdk) openjdk version "1.8.0-internal" OpenJDK Runtime Environment (build 1.8.0-internal-sandoz_2013_06_19_10_35-b00) OpenJDK 64-Bit Server VM (build 25.0-b36, mixed mode) ACTION: build -- Passed. Build successful REASON: Named class compiled on demand TIME: 5.992 seconds messages: command: build java.util.stream.DoubleNodeTest java.util.stream.FlagOpTest java.util.stream.IntNodeTest java.util.stream.LongNodeTest java.util.stream.NodeBuilderTest java.util.stream.NodeTest java.util.stream.SliceSpliteratorTest java.util.stream.SpinedBufferTest java.util.stream.StreamFlagsTest java.util.stream.StreamOpFlagsTest java.util.stream.StreamReuseTest java.util.stream.UnorderedTest java.util.stream.CollectorOps java.util.stream.DoubleStreamTestDataProvider java.util.stream.DoubleStreamTestScenario java.util.stream.FlagDeclaringOp java.util.stream.IntermediateTestOp java.util.stream.IntStreamTestDataProvider java.util.stream.IntStreamTestScenario java.util.stream.LambdaTestHelpers java.util.stream.LoggingTestCase java.util.stream.LongStreamTestDataProvider java.util.stream.LongStreamTestScenario java.util.stream.OpTestCase java.util.stream.SpliteratorTestHelper java.util.stream.StatefulTestOp java.util.stream.StatelessTestOp java.util.stream.StreamOpFlagTestHelper java.util.stream.StreamTestDataProvider java.util.stream.StreamTestScenario java.util.stream.TestData java.util.stream.TestFlagExpectedOp reason: Named class compiled on demand elapsed time (seconds): 5.992 ACTION: compile -- Passed. Compilation successful REASON: .class file out of date or does not exist TIME: 3.459 seconds messages: command: compile -XDignore.symbol.file=true -implicit:none /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/SliceSpliteratorTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java reason: .class file out of date or does not exist elapsed time (seconds): 3.459 STDOUT: STDERR: ACTION: compile -- Passed. Compilation successful REASON: .class file out of date or does not exist TIME: 2.527 seconds messages: command: compile -XDignore.symbol.file=true -implicit:none /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/FlagDeclaringOp.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/LoggingTestCase.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvider.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/StatelessTestOp.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java /Users/sandoz/Projects/jdk8/lambda/jdk/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java reason: .class file out of date or does not exist elapsed time (seconds): 2.527 STDOUT: STDERR: ACTION: testng -- Passed. Execution successful REASON: Assumed action based on file name: run testng java.util.stream.SpinedBufferTest TIME: 22.474 seconds messages: command: testng java.util.stream.SpinedBufferTest reason: Assumed action based on file name: run testng java.util.stream.SpinedBufferTest elapsed time (seconds): 22.474 STDOUT: [TestNG] Running: java/util/stream/boottest/java/util/stream/SpinedBufferTest.java ... =============================================== java/util/stream/boottest/java/util/stream/SpinedBufferTest.java Total tests run: 928, Failures: 0, Skips: 0 =============================================== > -- Jon > > On 06/24/2013 03:35 PM, Gary Collins wrote: >> >> >> >> jtreg test case I was talking about. I think its doing to much. Might be a good candidate for breakup >> jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> >> I bumped up the mem to 128mb and it still failed. >> >> Gary >> >> emb-sca-mv-plug-6281-3:/tmp# /export/local/common/jtreg/linux/bin/jtreg -verbose:all -timeout:25 -vmoptions:"-Xmx128m -Xms128m" -Xmx128m -jdk:/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> Directory "JTwork" not found: creating >> Directory "JTreport" not found: creating >> -------------------------------------------------- >> TEST: java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> JDK under test: (/java/east/sqe/jdk/ejavase/8/b91/jdk/linux-armsflt) >> java version "1.8.0-ea" >> Java(TM) SE Embedded Runtime Environment (build 1.8.0-ea-b91) >> Java HotSpot(TM) Embedded Client VM (build 25.0-b33, mixed mode) >> >> >> ACTION: build -- Passed. Build successful >> REASON: Named class compiled on demand >> TIME: 118.131 seconds >> messages: >> command: build java.util.stream.FlagOpTest java.util.stream.DoubleNodeTest java.util.stream.UnorderedTest java.util.stream.NodeTest java.util.stream.StreamOpFlagsTest java.util.stream.SpinedBufferTest java.util.stream.StreamFlagsTest java.util.stream.NodeBuilderTest java.util.stream.IntNodeTest java.util.stream.LongNodeTest java.util.stream.StreamReuseTest java.util.stream.OpTestCase java.util.stream.DoubleStreamTestDataProvider java.util.stream.DoubleStreamTestScenario java.util.stream.StreamTestScenario java.util.stream.StreamOpFlagTestHelper java.util.stream.IntermediateTestOp java.util.stream.SpliteratorTestHelper java.util.stream.LongStreamTestScenario java.util.stream.StatelessTestOp java.util.stream.TestFlagExpectedOp java.util.stream.StreamTestDataProvider java.util.stream.TestData java.util.stream.IntStreamTestDataProvider java.util.stream.StatefulTestOp java.util.stream.CollectorOps java.util.stream.IntStreamTestScenario java.util.stream.LambdaTestHelpers java.ut! > il.stream.LongStreamTestDataProvider java.util.stream.FlagDeclaringOp >> reason: Named class compiled on demand >> elapsed time (seconds): 118.131 >> >> ACTION: compile -- Passed. Compilation successful >> REASON: .class file out of date or does not exist >> TIME: 63.659 seconds >> messages: >> command: compile -XDignore.symbol.file=true -implicit:none /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/FlagOpTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/DoubleNodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/UnorderedTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamOpFlagsTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/SpinedBufferTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamFlagsTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/NodeBuilderTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/IntNodeTest.java /export/! > users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/LongNodeTest.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boottest/java/util/stream/StreamReuseTest.java >> reason: .class file out of date or does not exist >> elapsed time (seconds): 63.659 >> STDOUT: >> STDERR: >> >> ACTION: compile -- Passed. Compilation successful >> REASON: .class file out of date or does not exist >> TIME: 54.331 seconds >> messages: >> command: compile -XDignore.symbol.file=true -implicit:none /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/OpTestCase.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/DoubleStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamOpFlagTestHelper.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntermediateTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/SpliteratorTestHelper.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot! > lib/java/util/stream/StatelessTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestFlagExpectedOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/TestData.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestDataProvider.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/StatefulTestOp.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/CollectorOps.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/IntStreamTestScenario.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/bootlib/java/util/stream/LongStreamTestDataProvi! > der.java /export/users/gmcollin/ws/jdk8/jdk/test/java/util/stream/boot > lib/java/util/stream/FlagDeclaringOp.java >> reason: .class file out of date or does not exist >> elapsed time (seconds): 54.331 >> STDOUT: >> STDERR: >> >> ACTION: testng -- Failed. Execution failed: `main' threw exception: java.lang.OutOfMemoryError: Java heap space >> REASON: Assumed action based on file name: run testng java.util.stream.SpinedBufferTest >> TIME: 1814.868 seconds >> messages: >> command: testng java.util.stream.SpinedBufferTest >> reason: Assumed action based on file name: run testng java.util.stream.SpinedBufferTest >> elapsed time (seconds): 1814.868 >> STDOUT: >> [TestNG] Running: >> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> >> test public void java.util.stream.SpinedBufferTest.testDoubleSpinedBuffer(): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testDoubleSpliterator(double[],java.util.stream.SpinedBuffer$OfDouble): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntLastSplit(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpinedBuffer(): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testIntSpliterator(int[],java.util.stream.SpinedBuffer$OfInt): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testLastSplit(int[],java.util.stream.SpinedBuffer): success >> test public void java.util >> >> ... >> Output overflow: >> JT Harness has limited the test output to the text to that >> at the beginning and the end, so that you can see how the >> test began, and how it completed. >> >> If you need to see more of the output from the test, >> set the system property javatest.maxOutputSize to a higher >> value. The current value is 100000 >> ... >> >> .testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongLastSplit(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpinedBuffer(): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testLongSpliterator(long[],java.util.stream.SpinedBuffer$OfLong): success >> test public void java.util.stream.SpinedBufferTest.testSpinedBuffer(): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> test public void java.util.stream.SpinedBufferTest.testSpliterator(int[],java.util.stream.SpinedBuffer): success >> >> =============================================== >> java/util/stream/boottest/java/util/stream/SpinedBufferTest.java >> Total tests run: 928, Failures: 0, Skips: 0 >> =============================================== >> >> STDERR: >> java.lang.OutOfMemoryError: Java heap space >> at java.util.Arrays.copyOf(Arrays.java:3002) >> at java.lang.AbstractStringBuilder.expandCapacity(AbstractStringBuilder.java:137) >> at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:121) >> at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:622) >> at java.lang.StringBuilder.append(StringBuilder.java:202) >> at org.testng.internal.Utils.escapeUnicode(Utils.java:567) >> at org.testng.internal.Utils.writeUtf8File(Utils.java:115) >> at org.testng.reporters.XMLReporter.generateReport(XMLReporter.java:66) >> at org.testng.TestNG.generateReports(TestNG.java:1088) >> at org.testng.TestNG.run(TestNG.java:1047) >> at com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:155) >> at com.sun.javatest.regtest.TestNGAction$TestNGRunner.main(TestNGAction.java:139) >> at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) >> at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) >> at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) >> at java.lang.reflect.Method.invoke(Method.java:491) >> at com.sun.javatest.regtest.MainWrapper$MainThread.run(MainWrapper.java:94) >> at java.lang.Thread.run(Thread.java:724) >> >> JavaTest Message: Test threw exception: java.lang.OutOfMemoryError: Java heap space >> JavaTest Message: shutting down test >> >> STATUS:Failed.`main' threw exception: java.lang.OutOfMemoryError: Java heap space >> >> TEST RESULT: Failed. Execution failed: `main' threw exception: java.lang.OutOfMemoryError: Java heap space >> -------------------------------------------------- >> Test results: failed: 1 >> >> Report written to /tmp/JTreport/html/report.html >> Results written to /tmp/JTwork >> Error: Some tests failed or other problems occurred. >> > > > From chris.hegarty at oracle.com Tue Jun 25 10:00:11 2013 From: chris.hegarty at oracle.com (Chris Hegarty) Date: Tue, 25 Jun 2013 18:00:11 +0100 Subject: hg: lambda/lambda/jdk: 3 new changesets In-Reply-To: <20130625142642.72908484EB@hg.openjdk.java.net> References: <20130625142642.72908484EB@hg.openjdk.java.net> Message-ID: <51C9CC9B.7040207@oracle.com> On 06/25/2013 03:25 PM, paul.sandoz at oracle.com wrote: > .... > Changeset: 93a086ba83ff > Author: psandoz > Date: 2013-06-25 16:23 +0200 > URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/93a086ba83ff > > Tests for array parallel prefix and set all. > Contributed-by: Tristan Yan > > + test/java/util/Arrays/ParallelPrefix.java > + test/java/util/Arrays/ParallelSet.java Nice test for ParallelPrefix, I'll pull it into jdk8 along with the changes themselves. Trivially, the dependency on the sqeutil library can be removed. diff -r 2b3b4f067ebe test/java/util/Arrays/ParallelPrefix.java --- a/test/java/util/Arrays/ParallelPrefix.java Tue Jun 25 16:29:38 2013 +0200 +++ b/test/java/util/Arrays/ParallelPrefix.java Tue Jun 25 17:57:13 2013 +0100 @@ -24,8 +24,6 @@ /** * @test * @summary unit test for Arrays.ParallelPrefix(). - * @library /sqeutil - * @(#) ParallelPrefix.java * @author Tristan Yan * @run testng ParallelPrefix */ -Chris. From paul.sandoz at oracle.com Tue Jun 25 10:16:25 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Tue, 25 Jun 2013 19:16:25 +0200 Subject: hg: lambda/lambda/jdk: 3 new changesets In-Reply-To: <51C9CC9B.7040207@oracle.com> References: <20130625142642.72908484EB@hg.openjdk.java.net> <51C9CC9B.7040207@oracle.com> Message-ID: On Jun 25, 2013, at 7:00 PM, Chris Hegarty wrote: > On 06/25/2013 03:25 PM, paul.sandoz at oracle.com wrote: >> .... >> Changeset: 93a086ba83ff >> Author: psandoz >> Date: 2013-06-25 16:23 +0200 >> URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/93a086ba83ff >> >> Tests for array parallel prefix and set all. >> Contributed-by: Tristan Yan >> >> + test/java/util/Arrays/ParallelPrefix.java >> + test/java/util/Arrays/ParallelSet.java > > Nice test for ParallelPrefix, I'll pull it into jdk8 along with the changes themselves. > Great. > Trivially, the dependency on the sqeutil library can be removed. > Thanks i updated both tests. Paul. From paul.sandoz at oracle.com Tue Jun 25 10:15:56 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Tue, 25 Jun 2013 17:15:56 +0000 Subject: hg: lambda/lambda/jdk: Remove unused jtreg meta-data Message-ID: <20130625171620.2E926484FC@hg.openjdk.java.net> Changeset: 54f3d8ed2428 Author: psandoz Date: 2013-06-25 19:14 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/54f3d8ed2428 Remove unused jtreg meta-data Contributed-by: Chris Hegarty ! test/java/util/Arrays/ParallelPrefix.java ! test/java/util/Arrays/ParallelSet.java From mike.duigou at oracle.com Tue Jun 25 11:06:45 2013 From: mike.duigou at oracle.com (Mike Duigou) Date: Tue, 25 Jun 2013 12:06:45 -0600 Subject: RFR (2nd round) 8009736: Comparator API cleanup In-Reply-To: <51C1EA92.9010102@oracle.com> References: <51B790E6.6020209@oracle.com> <51BCF8B6.4050307@oracle.com> <51C1EA92.9010102@oracle.com> Message-ID: <3A510BB7-1F00-49BE-8AD6-DBAEA38B76A6@oracle.com> Looks good. Only a few minor nits. A few places (BiOperator) where it says "Constructs" rather than "Returns". If it is important that it constructs a new instance for consistency you may wish to say "Returns a new ..." There are a few places of incorrect capitalization in @return and @param tags Mike On Jun 19 2013, at 11:29 , Henry Jen wrote: > A ping to wake up the thread, there is a minor update regard the use of > @apiNote since last email. > > Thanks in advance for reviewing. > > Cheers, > Henry > > > On 06/15/2013 04:28 PM, Henry Jen wrote: >> Reflecting feedbacks received so far, please see >> >> http://cr.openjdk.java.net/~henryjen/ccc/8009736.3/webrev/ >> http://cr.openjdk.java.net/~henryjen/ccc/8009736.3/specdiff >> >> Cheers, >> Henry >> >> >> On 06/11/2013 02:04 PM, Henry Jen wrote: >>> Hi, >>> >>> Please review http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/webrev/ >>> >>> Highlight of changes, >>> >>> - Comparators class is now only package-private implementations. The >>> public static methods have been move to other arguably more appropriate >>> places, mostly in Comparator. >>> >>> - Comparator.reverseOrder() is renamed to Comparator.reversed() >>> >>> - nullsFirst(Comparator) and nullsLast(Comparator) are introduced to >>> wrap up a comparator to be null-friendly. >>> >>> To see the API changes, found the specdiff at >>> http://cr.openjdk.java.net/~henryjen/ccc/8009736.2/specdiff/overview-summary.html >>> >>> Cheers, >>> Henry >>> >> > From brian.goetz at oracle.com Tue Jun 25 13:27:25 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Tue, 25 Jun 2013 20:27:25 +0000 Subject: hg: lambda/lambda/jdk: Spec tweaks from EG review Message-ID: <20130625202751.37CEE4850C@hg.openjdk.java.net> Changeset: 5d2bbe0c3b32 Author: briangoetz Date: 2013-06-25 16:27 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5d2bbe0c3b32 Spec tweaks from EG review ! src/share/classes/java/util/stream/Collector.java ! src/share/classes/java/util/stream/Collectors.java From henry.jen at oracle.com Tue Jun 25 14:59:21 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Tue, 25 Jun 2013 21:59:21 +0000 Subject: hg: lambda/lambda/hotspot: 8005849: JEP 167: Event-Based JVM Tracing Message-ID: <20130625215925.A9E6F48524@hg.openjdk.java.net> Changeset: 7b772f9e0365 Author: sla Date: 2013-06-10 11:30 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/hotspot/rev/7b772f9e0365 8005849: JEP 167: Event-Based JVM Tracing Reviewed-by: acorn, coleenp, sla Contributed-by: Karen Kinnear , Bengt Rutisson , Calvin Cheung , Erik Gahlin , Erik Helin , Jesper Wilhelmsson , Keith McGuigan , Mattias Tobiasson , Markus Gronlund , Mikael Auno , Nils Eliasson , Nils Loodin , Rickard Backman , Staffan Larsen , Stefan Karlsson , Yekaterina Kantserova ! make/Makefile ! make/bsd/makefiles/buildtree.make ! make/bsd/makefiles/minimal1.make ! make/bsd/makefiles/top.make + make/bsd/makefiles/trace.make ! make/bsd/makefiles/vm.make ! make/defs.make ! make/excludeSrc.make ! make/linux/makefiles/buildtree.make ! make/linux/makefiles/minimal1.make ! make/linux/makefiles/top.make + make/linux/makefiles/trace.make ! make/linux/makefiles/vm.make ! make/solaris/makefiles/buildtree.make ! make/solaris/makefiles/top.make + make/solaris/makefiles/trace.make ! make/solaris/makefiles/vm.make ! make/windows/build.make ! make/windows/create_obj_files.sh ! make/windows/makefiles/generated.make ! make/windows/makefiles/projectcreator.make + make/windows/makefiles/trace.make ! make/windows/makefiles/vm.make ! make/windows/projectfiles/common/Makefile ! src/cpu/sparc/vm/frame_sparc.cpp ! src/cpu/x86/vm/frame_x86.cpp ! src/os/bsd/vm/osThread_bsd.hpp ! src/os/bsd/vm/os_bsd.cpp ! src/os/bsd/vm/os_bsd.hpp ! src/os/bsd/vm/os_bsd.inline.hpp ! src/os/linux/vm/osThread_linux.hpp ! src/os/linux/vm/os_linux.cpp ! src/os/linux/vm/os_linux.hpp ! src/os/linux/vm/os_linux.inline.hpp ! src/os/solaris/vm/osThread_solaris.cpp ! src/os/solaris/vm/osThread_solaris.hpp ! src/os/solaris/vm/os_share_solaris.hpp ! src/os/solaris/vm/os_solaris.cpp ! src/os/solaris/vm/os_solaris.hpp ! src/os/windows/vm/os_windows.cpp ! src/os_cpu/bsd_x86/vm/thread_bsd_x86.cpp ! src/os_cpu/bsd_x86/vm/thread_bsd_x86.hpp ! src/os_cpu/linux_x86/vm/thread_linux_x86.cpp ! src/os_cpu/linux_x86/vm/thread_linux_x86.hpp ! src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp ! src/os_cpu/solaris_sparc/vm/thread_solaris_sparc.cpp ! src/os_cpu/solaris_sparc/vm/thread_solaris_sparc.hpp ! src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp ! src/os_cpu/solaris_x86/vm/thread_solaris_x86.cpp ! src/os_cpu/solaris_x86/vm/thread_solaris_x86.hpp ! src/os_cpu/windows_x86/vm/thread_windows_x86.cpp ! src/os_cpu/windows_x86/vm/thread_windows_x86.hpp ! src/share/tools/ProjectCreator/BuildConfig.java ! src/share/vm/classfile/classFileParser.cpp ! src/share/vm/classfile/classLoaderData.cpp ! src/share/vm/classfile/classLoaderData.hpp ! src/share/vm/classfile/javaClasses.cpp ! src/share/vm/classfile/systemDictionary.cpp ! src/share/vm/classfile/systemDictionary.hpp ! src/share/vm/code/codeCache.cpp ! src/share/vm/code/codeCache.hpp ! src/share/vm/compiler/compileBroker.cpp ! src/share/vm/compiler/compileBroker.hpp ! src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp ! src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp ! src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.cpp ! src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp ! src/share/vm/gc_implementation/g1/concurrentMark.cpp ! src/share/vm/gc_implementation/g1/concurrentMark.hpp ! src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp + src/share/vm/gc_implementation/g1/evacuationInfo.hpp ! src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp ! src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp ! src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp ! src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp ! src/share/vm/gc_implementation/g1/g1GCPhaseTimes.hpp ! src/share/vm/gc_implementation/g1/g1MarkSweep.cpp ! src/share/vm/gc_implementation/g1/g1MarkSweep.hpp ! src/share/vm/gc_implementation/g1/g1MonitoringSupport.hpp + src/share/vm/gc_implementation/g1/g1YCTypes.hpp ! src/share/vm/gc_implementation/g1/vm_operations_g1.cpp ! src/share/vm/gc_implementation/parNew/parNewGeneration.cpp ! src/share/vm/gc_implementation/parNew/parNewGeneration.hpp ! src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp ! src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp ! src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp ! src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp ! src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp ! src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp ! src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp ! src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp ! src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp ! src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp + src/share/vm/gc_implementation/shared/copyFailedInfo.hpp + src/share/vm/gc_implementation/shared/gcHeapSummary.hpp + src/share/vm/gc_implementation/shared/gcTimer.cpp + src/share/vm/gc_implementation/shared/gcTimer.hpp + src/share/vm/gc_implementation/shared/gcTrace.cpp + src/share/vm/gc_implementation/shared/gcTrace.hpp + src/share/vm/gc_implementation/shared/gcTraceSend.cpp + src/share/vm/gc_implementation/shared/gcTraceTime.cpp + src/share/vm/gc_implementation/shared/gcTraceTime.hpp + src/share/vm/gc_implementation/shared/gcWhen.hpp ! src/share/vm/gc_implementation/shared/markSweep.cpp ! src/share/vm/gc_implementation/shared/markSweep.hpp ! src/share/vm/gc_implementation/shared/vmGCOperations.cpp ! src/share/vm/gc_implementation/shared/vmGCOperations.hpp + src/share/vm/gc_interface/allocTracer.cpp + src/share/vm/gc_interface/allocTracer.hpp ! src/share/vm/gc_interface/collectedHeap.cpp ! src/share/vm/gc_interface/collectedHeap.hpp ! src/share/vm/gc_interface/collectedHeap.inline.hpp ! src/share/vm/gc_interface/gcCause.cpp ! src/share/vm/gc_interface/gcCause.hpp + src/share/vm/gc_interface/gcName.hpp ! src/share/vm/memory/allocation.hpp ! src/share/vm/memory/defNewGeneration.cpp ! src/share/vm/memory/defNewGeneration.hpp ! src/share/vm/memory/genCollectedHeap.cpp ! src/share/vm/memory/genMarkSweep.cpp ! src/share/vm/memory/generation.cpp ! src/share/vm/memory/heapInspection.cpp ! src/share/vm/memory/heapInspection.hpp + src/share/vm/memory/klassInfoClosure.hpp ! src/share/vm/memory/metaspace.hpp ! src/share/vm/memory/oopFactory.hpp ! src/share/vm/memory/referenceProcessor.cpp ! src/share/vm/memory/referenceProcessor.hpp + src/share/vm/memory/referenceProcessorStats.hpp + src/share/vm/memory/referenceType.hpp ! src/share/vm/memory/universe.cpp ! src/share/vm/memory/universe.hpp ! src/share/vm/oops/instanceKlass.hpp ! src/share/vm/oops/klass.cpp ! src/share/vm/opto/compile.cpp ! src/share/vm/opto/compile.hpp ! src/share/vm/opto/escape.cpp ! src/share/vm/opto/library_call.cpp ! src/share/vm/opto/loopnode.cpp ! src/share/vm/opto/matcher.cpp + src/share/vm/opto/phasetype.hpp ! src/share/vm/precompiled/precompiled.hpp ! src/share/vm/prims/jni.cpp ! src/share/vm/prims/jvm.cpp ! src/share/vm/prims/jvmtiGen.java ! src/share/vm/prims/jvmtiImpl.cpp ! src/share/vm/prims/jvmtiImpl.hpp ! src/share/vm/prims/unsafe.cpp ! src/share/vm/runtime/frame.hpp ! src/share/vm/runtime/frame.inline.hpp ! src/share/vm/runtime/globals.hpp ! src/share/vm/runtime/java.cpp ! src/share/vm/runtime/mutexLocker.cpp ! src/share/vm/runtime/objectMonitor.cpp ! src/share/vm/runtime/objectMonitor.hpp ! src/share/vm/runtime/os.cpp ! src/share/vm/runtime/os.hpp ! src/share/vm/runtime/perfData.cpp ! src/share/vm/runtime/perfData.hpp ! src/share/vm/runtime/stubRoutines.hpp ! src/share/vm/runtime/sweeper.cpp ! src/share/vm/runtime/sweeper.hpp ! src/share/vm/runtime/synchronizer.cpp ! src/share/vm/runtime/task.cpp ! src/share/vm/runtime/thread.cpp ! src/share/vm/runtime/thread.hpp ! src/share/vm/runtime/timer.cpp ! src/share/vm/runtime/timer.hpp ! src/share/vm/runtime/vmStructs.cpp ! src/share/vm/runtime/vmThread.cpp ! src/share/vm/runtime/vm_operations.cpp ! src/share/vm/runtime/vm_operations.hpp ! src/share/vm/services/attachListener.cpp ! src/share/vm/services/diagnosticArgument.cpp ! src/share/vm/services/diagnosticCommand.cpp ! src/share/vm/services/memBaseline.cpp + src/share/vm/trace/noTraceBackend.hpp + src/share/vm/trace/trace.dtd + src/share/vm/trace/trace.xml + src/share/vm/trace/traceBackend.hpp + src/share/vm/trace/traceDataTypes.hpp + src/share/vm/trace/traceEvent.hpp + src/share/vm/trace/traceEventClasses.xsl + src/share/vm/trace/traceEventIds.xsl - src/share/vm/trace/traceEventTypes.hpp ! src/share/vm/trace/traceMacros.hpp + src/share/vm/trace/traceStream.hpp + src/share/vm/trace/traceTime.hpp + src/share/vm/trace/traceTypes.xsl + src/share/vm/trace/tracetypes.xml ! src/share/vm/trace/tracing.hpp + src/share/vm/trace/xinclude.mod + src/share/vm/trace/xsl_util.xsl ! src/share/vm/utilities/globalDefinitions.hpp ! src/share/vm/utilities/macros.hpp From henry.jen at oracle.com Tue Jun 25 15:48:35 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Tue, 25 Jun 2013 22:48:35 +0000 Subject: hg: lambda/lambda/jdk: concat is moved from Streams to Stream Message-ID: <20130625224858.EBBB948526@hg.openjdk.java.net> Changeset: 8975674bfabc Author: henryjen Date: 2013-06-25 15:47 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/8975674bfabc concat is moved from Streams to Stream ! test/java/util/stream/Stream/IntStreamTest.java From henry.jen at oracle.com Tue Jun 25 22:32:33 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Wed, 26 Jun 2013 05:32:33 +0000 Subject: hg: lambda/lambda/jdk: Review feedbacks on javadoc Message-ID: <20130626053248.40AAF48537@hg.openjdk.java.net> Changeset: c78083093dab Author: henryjen Date: 2013-06-25 20:53 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c78083093dab Review feedbacks on javadoc ! src/share/classes/java/util/Comparator.java ! src/share/classes/java/util/Map.java ! src/share/classes/java/util/function/BinaryOperator.java From henry.jen at oracle.com Wed Jun 26 00:55:12 2013 From: henry.jen at oracle.com (Henry Jen) Date: Wed, 26 Jun 2013 00:55:12 -0700 Subject: RFR (3rd) 8009736: Comparator API cleanup Message-ID: <51CA9E60.6060108@oracle.com> Hi, Thanks for all the reviewing, hopefully this would be the last round as we addressed feedbacks. Mostly the difference from last round is javadoc[1], the only code change[2] is that we override the default method of Comparator.reversed() for natural/reverse order comparator in Collections and Comparators as Peter Levart suggested. [1] http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c78083093dab [2] http://hg.openjdk.java.net/lambda/lambda/jdk/rev/85308d92a4d6 Cheers, Henry From henry.jen at oracle.com Wed Jun 26 00:47:04 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Wed, 26 Jun 2013 07:47:04 +0000 Subject: hg: lambda/lambda/jdk: Override Comparator::reversed Message-ID: <20130626074730.E24254853E@hg.openjdk.java.net> Changeset: 85308d92a4d6 Author: henryjen Date: 2013-06-26 00:31 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/85308d92a4d6 Override Comparator::reversed ! src/share/classes/java/util/Collections.java ! src/share/classes/java/util/Comparators.java From paul.sandoz at oracle.com Wed Jun 26 01:20:19 2013 From: paul.sandoz at oracle.com (Paul Sandoz) Date: Wed, 26 Jun 2013 10:20:19 +0200 Subject: RFR (3rd) 8009736: Comparator API cleanup In-Reply-To: <51CA9E60.6060108@oracle.com> References: <51CA9E60.6060108@oracle.com> Message-ID: <2340B783-A56F-45E6-9A85-6A3087E1DCCF@oracle.com> HI Henry, I think this is good to push, and we can tweak other stuff as required with further commits. I can push for you if you like. Paul. On Jun 26, 2013, at 9:55 AM, Henry Jen wrote: > Hi, > > Thanks for all the reviewing, hopefully this would be the last round as > we addressed feedbacks. > > Mostly the difference from last round is javadoc[1], the only code > change[2] is that we override the default method of > Comparator.reversed() for natural/reverse order comparator in > Collections and Comparators as Peter Levart suggested. > > [1] http://hg.openjdk.java.net/lambda/lambda/jdk/rev/c78083093dab > [2] http://hg.openjdk.java.net/lambda/lambda/jdk/rev/85308d92a4d6 > > Cheers, > Henry From robert.field at oracle.com Wed Jun 26 08:19:15 2013 From: robert.field at oracle.com (robert.field at oracle.com) Date: Wed, 26 Jun 2013 15:19:15 +0000 Subject: hg: lambda/lambda/jdk: 8016761: Lambda metafactory - incorrect type conversion of constructor method handle Message-ID: <20130626151939.7D6B648552@hg.openjdk.java.net> Changeset: 261442107943 Author: rfield Date: 2013-06-26 08:18 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/261442107943 8016761: Lambda metafactory - incorrect type conversion of constructor method handle Reviewed-by: jrose ! src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java + test/java/lang/invoke/lambda/LambdaConstructorMethodHandleUnbox.java From maurizio.cimadamore at oracle.com Wed Jun 26 09:33:52 2013 From: maurizio.cimadamore at oracle.com (Maurizio Cimadamore) Date: Wed, 26 Jun 2013 17:33:52 +0100 Subject: Invalid method reference with generics In-Reply-To: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> References: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> Message-ID: <51CB17F0.9040503@oracle.com> Hi Nick, method reference applicability is defined in a way so that the parameter types inferred from the target (ApplicationEvent in your case) should be compatible with the argument types in the method reference signature (Event1/Event2 in your case). Since ApplicationEvent is _not_ a subtype of Event1/Event2 (it's the other way around), the method reference is not compatible with that target. Maurizio On 23/06/13 18:59, Nick Williams wrote: > Given this interface: > > public interface ApplicationListener extends EventListener { > void onApplicationEvent(E e); > } > > And these two events: > > public class Event2 extends ApplicationEvent { > public Event1(Object source) { > super(source); > } > } > > public class Event2 extends ApplicationEvent { > public Event2(Object source) { > super(source); > } > } > > And this class: > > public class MyBean { > public void onEvent1(Event1 event1) { } > > public void onEvent2(Event2 event2) { } > > public void initialize() { > register(this::onEvent2); > } > > public static void register(ApplicationListener listener) { } > // I've also tried public static void register(ApplicationListener listener) { } > // I've also tried public static void register(ApplicationListener listener) { } > // I've also tried public static void register(ApplicationListener listener) { } > } > > Can someone tell my why this fails to compile with the following error? > > Error: java: incompatible types: invalid method reference > incompatible types: x.x.x.ApplicationEvent cannot be converted to x.x.x.Event2 > > This seems like quite the limitation. Why can't the compiler match onEvent2 to the method in ApplicationEvent? > > If I change onEvent2's signature to take an ApplicationEvent instead of an Event2, it compiles fine. If I change register's signature to take an ApplicationListener instead of an ApplicationListener, it also compiles fine. Is there some other way to do what I want to do here? > > Note: I also tried public static void register(ApplicationListener listener) { }, but that resulted in a different error, "Error: java: incompatible types: Cannot instantiate inference variables E because of an inference loop." > > Nick > From nicholas+openjdk at nicholaswilliams.net Wed Jun 26 10:13:14 2013 From: nicholas+openjdk at nicholaswilliams.net (Nick Williams) Date: Wed, 26 Jun 2013 12:13:14 -0500 Subject: Invalid method reference with generics In-Reply-To: <51CB17F0.9040503@oracle.com> References: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> <51CB17F0.9040503@oracle.com> Message-ID: <73611695-63E8-4923-85C3-FDEDF47AFEB1@nicholaswilliams.net> Hmmm. That's confusing and doesn't make sense. (For reference: ApplicationEvent extends EventObject). I could pass an ApplicationListener into register() (I did it and it works), because Event1 extends ApplicationListener. I can't pass an ApplicationListener into register(), because EventObject is a supertype of ApplicationLister, not a subtype. The way you describe it, it sounds like I _could_ pass a method reference that implements ApplicationListener into register() (which is not what I need to do) but I _could not_ pass a method reference that implements ApplicationListener (which is what I'm trying and failing to do). So, you're right (that's the way it works), but that's wrong (that's not the way it _should_ work). Look at this code: public class MyBean { public void onEventObject(EventObject object) { } public void initialize() { register(this::onEventObject); register(new ApplicationListener() { @Override public void onApplicationEvent(Event1 event) { } }); } public static void register(ApplicationListener listener) { } } That compiles and runs (I just tested it), but the two uses of register are completely opposite. Register with the anonymous inner class works as I expect: I can pass in an ApplicationListener whose type _extends_ ApplicationEvent. Register with the method reference is opposite: I can pass in an ApplicationListener whose type _is extended by_ ApplicationEvent. I am very convinced that that's wrong. In fact, my IDE highlights the anonymous inner class as a warning that says "Anonymous ApplicationListener" can be replaced with lambda," but when I let it replace it I get incompatible parameter types upon compilation. Nick On Jun 26, 2013, at 11:33 AM, Maurizio Cimadamore wrote: > Hi Nick, > method reference applicability is defined in a way so that the parameter types inferred from the target (ApplicationEvent in your case) should be compatible with the argument types in the method reference signature (Event1/Event2 in your case). Since ApplicationEvent is _not_ a subtype of Event1/Event2 (it's the other way around), the method reference is not compatible with that target. > > Maurizio > > On 23/06/13 18:59, Nick Williams wrote: >> Given this interface: >> >> public interface ApplicationListener extends EventListener { >> void onApplicationEvent(E e); >> } >> >> And these two events: >> >> public class Event2 extends ApplicationEvent { >> public Event1(Object source) { >> super(source); >> } >> } >> >> public class Event2 extends ApplicationEvent { >> public Event2(Object source) { >> super(source); >> } >> } >> >> And this class: >> >> public class MyBean { >> public void onEvent1(Event1 event1) { } >> >> public void onEvent2(Event2 event2) { } >> >> public void initialize() { >> register(this::onEvent2); >> } >> >> public static void register(ApplicationListener listener) { } >> // I've also tried public static void register(ApplicationListener listener) { } >> // I've also tried public static void register(ApplicationListener listener) { } >> // I've also tried public static void register(ApplicationListener listener) { } >> } >> >> Can someone tell my why this fails to compile with the following error? >> >> Error: java: incompatible types: invalid method reference >> incompatible types: x.x.x.ApplicationEvent cannot be converted to x.x.x.Event2 >> >> This seems like quite the limitation. Why can't the compiler match onEvent2 to the method in ApplicationEvent? >> >> If I change onEvent2's signature to take an ApplicationEvent instead of an Event2, it compiles fine. If I change register's signature to take an ApplicationListener instead of an ApplicationListener, it also compiles fine. Is there some other way to do what I want to do here? >> >> Note: I also tried public static void register(ApplicationListener listener) { }, but that resulted in a different error, "Error: java: incompatible types: Cannot instantiate inference variables E because of an inference loop." >> >> Nick >> > From maurizio.cimadamore at oracle.com Wed Jun 26 10:27:18 2013 From: maurizio.cimadamore at oracle.com (Maurizio Cimadamore) Date: Wed, 26 Jun 2013 18:27:18 +0100 Subject: Invalid method reference with generics In-Reply-To: <73611695-63E8-4923-85C3-FDEDF47AFEB1@nicholaswilliams.net> References: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> <51CB17F0.9040503@oracle.com> <73611695-63E8-4923-85C3-FDEDF47AFEB1@nicholaswilliams.net> Message-ID: <51CB2476.4040800@oracle.com> On 26/06/13 18:13, Nick Williams wrote: > That compiles and runs (I just tested it), but the two uses of register are completely opposite. Register with the anonymous inner class works as I expect: I can pass in an ApplicationListener whose type_extends_ ApplicationEvent. Register with the method reference is opposite: I can pass in an ApplicationListener whose type_is extended by_ ApplicationEvent. I am very convinced that that's wrong. In fact, my IDE highlights the anonymous inner class as a warning that says "Anonymous ApplicationListener" can be replaced with lambda," but when I let it replace it I get incompatible parameter types upon compilation. I think the fact that the IDE suggests that a lambda might be use is a bug in the lambda detector; a lambda cannot be used as, a lambda parameter type must be identical to that of the descriptor itr will be passed to. Subtyping is only allowed for method references, but the other way around, not the one you are asking for. Example: interface I { void m(Number n) } void g1(Object o) void g2(Number n) void g3(Integer i) void m(I i); m(this::g1); //ok, Number subtype of Object m(this::g2); //ok, Number subtype of Number m(this::g3); //error, Number not a subtype of Integer Note that this semantics is quite standard, as parameter types in function types are treated in a contravariant fashion (i.e. the function type accepting a more constrained domain is more general - this comes from Liskov - a subtype of a function type cannot start arbitrarily rejecting input values that were accepted by a super type). Maurizio From nicholas+openjdk at nicholaswilliams.net Wed Jun 26 10:43:58 2013 From: nicholas+openjdk at nicholaswilliams.net (Nick Williams) Date: Wed, 26 Jun 2013 12:43:58 -0500 Subject: Invalid method reference with generics In-Reply-To: <51CB2476.4040800@oracle.com> References: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> <51CB17F0.9040503@oracle.com> <73611695-63E8-4923-85C3-FDEDF47AFEB1@nicholaswilliams.net> <51CB2476.4040800@oracle.com> Message-ID: On Jun 26, 2013, at 12:27 PM, Maurizio Cimadamore wrote: > On 26/06/13 18:13, Nick Williams wrote: >> That compiles and runs (I just tested it), but the two uses of register are completely opposite. Register with the anonymous inner class works as I expect: I can pass in an ApplicationListener whose type_extends_ ApplicationEvent. Register with the method reference is opposite: I can pass in an ApplicationListener whose type_is extended by_ ApplicationEvent. I am very convinced that that's wrong. In fact, my IDE highlights the anonymous inner class as a warning that says "Anonymous ApplicationListener" can be replaced with lambda," but when I let it replace it I get incompatible parameter types upon compilation. > I think the fact that the IDE suggests that a lambda might be use is a bug in the lambda detector; a lambda cannot be used as, a lambda parameter type must be identical to that of the descriptor itr will be passed to. Subtyping is only allowed for method references, but the other way around, not the one you are asking for. > > Example: > > interface I { > void m(Number n) > } > > void g1(Object o) > void g2(Number n) > void g3(Integer i) > > void m(I i); > > m(this::g1); //ok, Number subtype of Object > m(this::g2); //ok, Number subtype of Number > m(this::g3); //error, Number not a subtype of Integer > > Note that this semantics is quite standard, as parameter types in function types are treated in a contravariant fashion (i.e. the function type accepting a more constrained domain is more general - this comes from Liskov - a subtype of a function type cannot start arbitrarily rejecting input values that were accepted by a super type). Indeed, this behavior makes sense _for methods whose argument types aren't indicated by type variables_. In my case, "interface I" is actually "interface ApplicationListener" and "m(Number n)" is actually "m(E e)." The argument type is, by definition, _intended_ to be more restrictive in implementing classes. My thought is "if it could be done with an anonymous inner class, it should be able to be done with a lambda expression." Weren't lambda expressions largely meant to replace any and all legal anonymous inner classes implementing one-method interfaces? To continue with your analogy above, it makes sense because I COULD NOT do this: m(new I() { public void m(Integer i) { } }); That would naturally result in a compile error, as it should, because I#m() takes a Number and Integer is more restrictive. However, I CAN do this (it compiles and runs just fine): register(new ApplicationListener() { public void onApplicationEvent(Event1 event) { } }); So, by extension, I SHOULD be able to do this, but can't: void onApplicationEvent(Event1 event) { } register(this::onApplicationEvent); We have inconsistent behavior here. In your example, both the method reference and the anonymous inner class are illegal. In my use case, the compiler allows the anonymous inner class but prohibits the method reference. That inconsistency is a real problem. There is _no_ semantic difference between what I'm doing with the anonymous inner class and what I'm doing with the method reference. Zero. The method signatures are identical (I event named them the same here to drive home the point), but one works and the other doesn't. Nick From brian.goetz at oracle.com Wed Jun 26 12:38:40 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Wed, 26 Jun 2013 19:38:40 +0000 Subject: hg: lambda/lambda/jdk: Add Characteristics... arguments to Collectors.of Message-ID: <20130626193903.0BCE74856A@hg.openjdk.java.net> Changeset: 567458424515 Author: briangoetz Date: 2013-06-26 15:38 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/567458424515 Add Characteristics... arguments to Collectors.of ! src/share/classes/java/util/stream/Collector.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/TabulatorsTest.java From brian.goetz at oracle.com Wed Jun 26 12:41:15 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Wed, 26 Jun 2013 19:41:15 +0000 Subject: hg: lambda/lambda/jdk: Add Iterable.spliterator() Message-ID: <20130626194127.D49E14856B@hg.openjdk.java.net> Changeset: a35de55b9a42 Author: briangoetz Date: 2013-06-26 15:41 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/a35de55b9a42 Add Iterable.spliterator() ! src/share/classes/java/lang/Iterable.java ! src/share/classes/java/util/Collection.java ! test-ng/build.xml ! test/java/util/Spliterator/SpliteratorCollisions.java ! test/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java From henry.jen at oracle.com Wed Jun 26 13:02:31 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Wed, 26 Jun 2013 20:02:31 +0000 Subject: hg: lambda/lambda/jdk: Revert forEach() back to ifPresent() for Optionals Message-ID: <20130626200254.1B90D48572@hg.openjdk.java.net> Changeset: 473ca46f3096 Author: henryjen Date: 2013-06-26 13:01 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/473ca46f3096 Revert forEach() back to ifPresent() for Optionals ! src/share/classes/java/util/Optional.java ! src/share/classes/java/util/OptionalDouble.java ! src/share/classes/java/util/OptionalInt.java ! src/share/classes/java/util/OptionalLong.java ! test/java/util/Optional/BasicDouble.java ! test/java/util/Optional/BasicInt.java ! test/java/util/Optional/BasicLong.java From richard.warburton at gmail.com Wed Jun 26 15:51:25 2013 From: richard.warburton at gmail.com (Richard Warburton) Date: Wed, 26 Jun 2013 23:51:25 +0100 Subject: Average vs Mean Message-ID: Hi, The 'average' method on specialised streams, such as DoubleStream, doesn't specify which form of average is to be used. Looking at the code in DoublePipeline its the mean. Would it be possible to say that the mean is used in the javadoc? I've noticed when talking to both Americans and Canadians that common usage is to equate average with mean. Whilst this is still the presumed colloquial interpretation in the UK the term 'average' is used to refer to any measure of central tendency. The terms mean, median and mode are used for the specific types of average. I appreciate this is a fairly 'picky' request, but I do think there's an easily clarified confusion here. regards, Dr. Richard Warburton http://insightfullogic.com @RichardWarburto From brian.goetz at oracle.com Wed Jun 26 18:11:07 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Wed, 26 Jun 2013 21:11:07 -0400 Subject: Average vs Mean In-Reply-To: References: Message-ID: <51CB912B.20808@oracle.com> I'll add a note. On 6/26/2013 6:51 PM, Richard Warburton wrote: > Hi, > > The 'average' method on specialised streams, such as DoubleStream, doesn't > specify which form of average is to be used. Looking at the code in > DoublePipeline its the mean. Would it be possible to say that the mean is > used in the javadoc? > > I've noticed when talking to both Americans and Canadians that common usage > is to equate average with mean. Whilst this is still the presumed > colloquial interpretation in the UK the term 'average' is used to refer to > any measure of central tendency. The terms mean, median and mode are used > for the specific types of average. > > I appreciate this is a fairly 'picky' request, but I do think there's an > easily clarified confusion here. > > regards, > > Dr. Richard Warburton > > http://insightfullogic.com > @RichardWarburto > From brian.goetz at oracle.com Wed Jun 26 18:14:33 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Thu, 27 Jun 2013 01:14:33 +0000 Subject: hg: lambda/lambda/jdk: Replace 'average' with 'arithmetic mean' for clarity Message-ID: <20130627011456.0873F48584@hg.openjdk.java.net> Changeset: eb9b9342c22e Author: briangoetz Date: 2013-06-26 21:14 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/eb9b9342c22e Replace 'average' with 'arithmetic mean' for clarity ! src/share/classes/java/util/DoubleSummaryStatistics.java ! src/share/classes/java/util/IntSummaryStatistics.java ! src/share/classes/java/util/LongSummaryStatistics.java ! src/share/classes/java/util/stream/Collectors.java ! src/share/classes/java/util/stream/DoubleStream.java ! src/share/classes/java/util/stream/IntStream.java ! src/share/classes/java/util/stream/LongStream.java From henry.jen at oracle.com Wed Jun 26 23:07:33 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Thu, 27 Jun 2013 06:07:33 +0000 Subject: hg: lambda/lambda/jdk: 8005008: Add Java Flight Recorder Phase II Message-ID: <20130627060759.BD271485A1@hg.openjdk.java.net> Changeset: 674296ab77c8 Author: sla Date: 2013-06-10 11:33 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/674296ab77c8 8005008: Add Java Flight Recorder Phase II Reviewed-by: erikj Contributed-by: Karen Kinnear , Bengt Rutisson , Calvin Cheung , Erik Gahlin , Erik Helin , Jesper Wilhelmsson , Keith McGuigan , Mattias Tobiasson , Markus Gronlund , Mikael Auno , Nils Eliasson , Nils Loodin , Rickard Backman , Staffan Larsen , Stefan Karlsson , Yekaterina Kantserova ! make/com/oracle/jfr/Makefile ! makefiles/CompileNativeLibraries.gmk ! makefiles/CopyFiles.gmk ! makefiles/CopyIntoClasses.gmk ! makefiles/CreateJars.gmk ! makefiles/mapfiles/libjfr/mapfile-vers ! makefiles/mapfiles/libjli/mapfile-vers ! src/share/lib/security/java.security-linux ! src/share/lib/security/java.security-macosx ! src/share/lib/security/java.security-solaris ! src/share/lib/security/java.security-windows From maurizio.cimadamore at oracle.com Thu Jun 27 00:35:45 2013 From: maurizio.cimadamore at oracle.com (Maurizio Cimadamore) Date: Thu, 27 Jun 2013 08:35:45 +0100 Subject: Invalid method reference with generics In-Reply-To: References: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> <51CB17F0.9040503@oracle.com> <73611695-63E8-4923-85C3-FDEDF47AFEB1@nicholaswilliams.net> <51CB2476.4040800@oracle.com> Message-ID: <51CBEB51.10302@oracle.com> On 26/06/13 18:43, Nick Williams wrote: > However, I CAN do this (it compiles and runs just fine): > > register(new ApplicationListener() { > public void onApplicationEvent(Event1 event) { } > }); > > So, by extension, I SHOULD be able to do this, but can't: > > void onApplicationEvent(Event1 event) { } > register(this::onApplicationEvent); > > We have inconsistent behavior here. In your example, both the method reference and the anonymous inner class are illegal. In my use case, the compiler allows the anonymous inner class but prohibits the method reference. That inconsistency is a real problem. There is_no_ semantic difference between what I'm doing with the anonymous inner class and what I'm doing with the method reference. Zero. The method signatures are identical (I event named them the same here to drive home the point), but one works and the other doesn't. > > Nick > Yes and no - the inner class you are creating is a subtype of: ApplicationListener while the type inferred by the compler as a target is: ApplicationListener (wildcard removed as per spec) This is why you get the 'weird' behavior. To express what you mean, you need to do the following: public static void register(ApplicationListener listener) { } The compiler will infer Z == Event1 and all will be fine. Well, it will fail with an inference error for now, but we have plans to fix that in the future. Maurizio From paul.sandoz at oracle.com Thu Jun 27 02:01:00 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 27 Jun 2013 09:01:00 +0000 Subject: hg: lambda/lambda/jdk: When the SliceOp.SliceTask is used there is a special case when the Message-ID: <20130627090128.2380A485B0@hg.openjdk.java.net> Changeset: 0c58fe330e2e Author: psandoz Date: 2013-06-27 10:49 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/0c58fe330e2e When the SliceOp.SliceTask is used there is a special case when the spliterator cannot be split (leaf == root) and for this case the op sink is resued, which skips and limits, so there is no need to truncate the node produced. See JDK-8017329. ! src/share/classes/java/util/stream/SliceOps.java ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java From paul.sandoz at oracle.com Thu Jun 27 02:04:22 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 27 Jun 2013 09:04:22 +0000 Subject: hg: lambda/lambda/jdk: Consolidate test code. Message-ID: <20130627090434.89190485B1@hg.openjdk.java.net> Changeset: 6e6c948105db Author: psandoz Date: 2013-06-27 11:04 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/6e6c948105db Consolidate test code. ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/SliceOpTest.java From paul.sandoz at oracle.com Thu Jun 27 05:29:31 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 27 Jun 2013 12:29:31 +0000 Subject: hg: lambda/lambda/jdk: Sync of some classes from 166. Message-ID: <20130627122953.F2260485B8@hg.openjdk.java.net> Changeset: 3f2563711847 Author: psandoz Date: 2013-06-27 14:29 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/3f2563711847 Sync of some classes from 166. ! src/share/classes/java/util/concurrent/BlockingDeque.java ! src/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java ! src/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java From paul.sandoz at oracle.com Thu Jun 27 05:35:03 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 27 Jun 2013 12:35:03 +0000 Subject: hg: lambda/lambda/jdk: Fix doc references. Message-ID: <20130627123515.63C01485B9@hg.openjdk.java.net> Changeset: 5acf515f2c63 Author: psandoz Date: 2013-06-27 14:34 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/5acf515f2c63 Fix doc references. ! src/share/classes/java/util/StringJoiner.java From paul.sandoz at oracle.com Thu Jun 27 06:09:14 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 27 Jun 2013 13:09:14 +0000 Subject: hg: lambda/lambda/jdk: Sync docs/code of classes from 166. Message-ID: <20130627130936.9CC34485BB@hg.openjdk.java.net> Changeset: 9a719172fc80 Author: psandoz Date: 2013-06-27 15:09 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/9a719172fc80 Sync docs/code of classes from 166. ! src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java ! src/share/classes/java/util/concurrent/CopyOnWriteArrayList.java ! src/share/classes/java/util/concurrent/CopyOnWriteArraySet.java From paul.sandoz at oracle.com Thu Jun 27 06:27:16 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 27 Jun 2013 13:27:16 +0000 Subject: hg: lambda/lambda/jdk: Updates from 166 to LinkedBlockingDeque, BlockingQueue and DelayQueue Message-ID: <20130627132738.E725C485BC@hg.openjdk.java.net> Changeset: da84789ac473 Author: psandoz Date: 2013-06-27 15:16 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/da84789ac473 Updates from 166 to LinkedBlockingDeque, BlockingQueue and DelayQueue ! src/share/classes/java/util/concurrent/BlockingQueue.java ! src/share/classes/java/util/concurrent/DelayQueue.java ! src/share/classes/java/util/concurrent/LinkedBlockingDeque.java From paul.sandoz at oracle.com Thu Jun 27 09:08:28 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 27 Jun 2013 16:08:28 +0000 Subject: hg: lambda/lambda/jdk: Use fully qualified Map.Entry rather than Entry. Message-ID: <20130627160852.2C011485C5@hg.openjdk.java.net> Changeset: cc8a7fb317e3 Author: psandoz Date: 2013-06-27 18:08 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/cc8a7fb317e3 Use fully qualified Map.Entry rather than Entry. ! src/share/classes/java/util/concurrent/ConcurrentSkipListMap.java From paul.sandoz at oracle.com Thu Jun 27 09:38:15 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Thu, 27 Jun 2013 16:38:15 +0000 Subject: hg: lambda/lambda/jdk: Improve and generalize the F/J tasks to handle right or Message-ID: <20130627163829.022C9485C9@hg.openjdk.java.net> Changeset: f5e31d5d1773 Author: psandoz Date: 2013-06-27 18:37 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/f5e31d5d1773 Improve and generalize the F/J tasks to handle right or left-balanced trees by alternating forking/computing the left/right tasks. This also has improved the resource usage over the previous version. Contributed-by: Doug Lea
! src/share/classes/java/util/stream/AbstractShortCircuitTask.java ! src/share/classes/java/util/stream/AbstractTask.java ! src/share/classes/java/util/stream/ForEachOps.java ! src/share/classes/java/util/stream/Nodes.java From scolebourne at joda.org Thu Jun 27 10:20:02 2013 From: scolebourne at joda.org (Stephen Colebourne) Date: Thu, 27 Jun 2013 18:20:02 +0100 Subject: Static method access dilemma and proposal: @NotInherited Message-ID: The addition of static methods on interfaces has given developers a new very useful tool. However, it has also produced a dliemma. A static method on a class is accessible/"inherited" by subclasses. Thus SubClass.foo() is just as good as SuperClass.foo() for accessing the static method defined on SuperClass. By contrast, with static methods on interfaces, this is not possible - a static method on an interface is not "inherited" (a Good Thing). The dliemma, from JSR-310 (https://github.com/ThreeTen/threeten/issues/321), is that I _really_ want to avoid the inheritance of static methods from one abstract class (Chronology), as the methods make no sense at all to be called on the subclasses, and in fact they may cause bugs. Thus, the new language feature pushes me to change the abstract class to be an interface *just to get the new static method behaviour*. In essence I have to make a new trade off between the right tool for the job (abstract class) and the right tool to avoid static method bugs (interface). It occured to me that as this was a new dliemma, I should report it here on lambda-dev. And propose a possible solution. Consider a new annotation @NotInherited that is only applicable to static methods. If a developer places it on a static method, then the method cannot be invoked by subclasses: public class A { @NotInherited public static void foo() {..} } public class B extends A { } { // other code A.foo(); // compiles B.foo(); // would not compile with this proposal } - Many IDEs support something similar today, but this would be enforced at the compiler level. - It is similar to @Override in conceptual scope, and is therefore suitable for an annotation. - It would not change the compiled bytecode at all, other than the standard storage for the additional annotation. - There are no reflection, security or backwards compatibility issues that I can see. - Adding the annotation to a previously published API would be backwards incompatible at the source level, but not the binary level - When compiling B against a previously compiled A, the annotation would be read from A's bytecode. - The annotation would not be processed by the JVM or verifier, thus B.foo() would be valid if it could be compiled (such as in a separate compilation scenario). - The change appears to be small, and thus not require a large effort to implement The annotation could be added to the JDK without enforcing it in javac, but that would seem to be a change not worth doing as it would rely on IDEs. Its easy to say that this is an old problem and so nothing needs to be done. But I hope I've tried to indicate that I think lambda's static methods on interfaces has changed the nature of the old problem and made it potentially more problematic in code design terms. Thoughts? Stephen From pbenedict at apache.org Thu Jun 27 10:50:24 2013 From: pbenedict at apache.org (Paul Benedict) Date: Thu, 27 Jun 2013 12:50:24 -0500 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: References: Message-ID: Stephen, it's an interesting idea. Bikeshed moment.... At the cost of having to recompile future code, I'd rather wish to have static methods on classes not be inheritable in JDK 9 and onward. Then the same behavior can be predictable across classes or interfaces. Fixing a bad language design is probably better than patching things up with @NotInherited. On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne wrote: > The addition of static methods on interfaces has given developers a > new very useful tool. However, it has also produced a dliemma. > > A static method on a class is accessible/"inherited" by subclasses. > Thus SubClass.foo() is just as good as SuperClass.foo() for accessing > the static method defined on SuperClass. By contrast, with static > methods on interfaces, this is not possible - a static method on an > interface is not "inherited" (a Good Thing). > > The dliemma, from JSR-310 > (https://github.com/ThreeTen/threeten/issues/321), is that I _really_ > want to avoid the inheritance of static methods from one abstract > class (Chronology), as the methods make no sense at all to be called > on the subclasses, and in fact they may cause bugs. Thus, the new > language feature pushes me to change the abstract class to be an > interface *just to get the new static method behaviour*. In essence I > have to make a new trade off between the right tool for the job > (abstract class) and the right tool to avoid static method bugs > (interface). > > It occured to me that as this was a new dliemma, I should report it > here on lambda-dev. And propose a possible solution. > > Consider a new annotation @NotInherited that is only applicable to > static methods. If a developer places it on a static method, then the > method cannot be invoked by subclasses: > > public class A { > @NotInherited > public static void foo() {..} > } > public class B extends A { > } > { // other code > A.foo(); // compiles > B.foo(); // would not compile with this proposal > } > > - Many IDEs support something similar today, but this would be > enforced at the compiler level. > - It is similar to @Override in conceptual scope, and is therefore > suitable for an annotation. > - It would not change the compiled bytecode at all, other than the > standard storage for the additional annotation. > - There are no reflection, security or backwards compatibility issues > that I can see. > - Adding the annotation to a previously published API would be > backwards incompatible at the source level, but not the binary level > - When compiling B against a previously compiled A, the annotation > would be read from A's bytecode. > - The annotation would not be processed by the JVM or verifier, thus > B.foo() would be valid if it could be compiled (such as in a separate > compilation scenario). > - The change appears to be small, and thus not require a large effort > to implement > > The annotation could be added to the JDK without enforcing it in > javac, but that would seem to be a change not worth doing as it would > rely on IDEs. > > Its easy to say that this is an old problem and so nothing needs to be > done. But I hope I've tried to indicate that I think lambda's static > methods on interfaces has changed the nature of the old problem and > made it potentially more problematic in code design terms. > > Thoughts? > Stephen > > From brian.goetz at oracle.com Thu Jun 27 11:14:34 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Thu, 27 Jun 2013 14:14:34 -0400 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: References: Message-ID: <51CC810A.8060003@oracle.com> Total agreement that it was a mistake to have them be inheritable. Static methods in interfaces don't have this defect. (And we took a hit for that inconsistency.) Unfortunately what you suggest for 9 is impractical for compatibility reasons. Overall I like Stephen's proposal here (except I am not convinced that it is suitable for an annotation, but that's a pretty superficial aspect of it.) Anything that moves us towards being able to fix this problem over time is good. On 6/27/2013 1:50 PM, Paul Benedict wrote: > Stephen, it's an interesting idea. Bikeshed moment.... At the cost of > having to recompile future code, I'd rather wish to have static methods on > classes not be inheritable in JDK 9 and onward. Then the same behavior can > be predictable across classes or interfaces. Fixing a bad language design > is probably better than patching things up with @NotInherited. > > > On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne > wrote: > >> The addition of static methods on interfaces has given developers a >> new very useful tool. However, it has also produced a dliemma. >> >> A static method on a class is accessible/"inherited" by subclasses. >> Thus SubClass.foo() is just as good as SuperClass.foo() for accessing >> the static method defined on SuperClass. By contrast, with static >> methods on interfaces, this is not possible - a static method on an >> interface is not "inherited" (a Good Thing). >> >> The dliemma, from JSR-310 >> (https://github.com/ThreeTen/threeten/issues/321), is that I _really_ >> want to avoid the inheritance of static methods from one abstract >> class (Chronology), as the methods make no sense at all to be called >> on the subclasses, and in fact they may cause bugs. Thus, the new >> language feature pushes me to change the abstract class to be an >> interface *just to get the new static method behaviour*. In essence I >> have to make a new trade off between the right tool for the job >> (abstract class) and the right tool to avoid static method bugs >> (interface). >> >> It occured to me that as this was a new dliemma, I should report it >> here on lambda-dev. And propose a possible solution. >> >> Consider a new annotation @NotInherited that is only applicable to >> static methods. If a developer places it on a static method, then the >> method cannot be invoked by subclasses: >> >> public class A { >> @NotInherited >> public static void foo() {..} >> } >> public class B extends A { >> } >> { // other code >> A.foo(); // compiles >> B.foo(); // would not compile with this proposal >> } >> >> - Many IDEs support something similar today, but this would be >> enforced at the compiler level. >> - It is similar to @Override in conceptual scope, and is therefore >> suitable for an annotation. >> - It would not change the compiled bytecode at all, other than the >> standard storage for the additional annotation. >> - There are no reflection, security or backwards compatibility issues >> that I can see. >> - Adding the annotation to a previously published API would be >> backwards incompatible at the source level, but not the binary level >> - When compiling B against a previously compiled A, the annotation >> would be read from A's bytecode. >> - The annotation would not be processed by the JVM or verifier, thus >> B.foo() would be valid if it could be compiled (such as in a separate >> compilation scenario). >> - The change appears to be small, and thus not require a large effort >> to implement >> >> The annotation could be added to the JDK without enforcing it in >> javac, but that would seem to be a change not worth doing as it would >> rely on IDEs. >> >> Its easy to say that this is an old problem and so nothing needs to be >> done. But I hope I've tried to indicate that I think lambda's static >> methods on interfaces has changed the nature of the old problem and >> made it potentially more problematic in code design terms. >> >> Thoughts? >> Stephen >> >> > From pbenedict at apache.org Thu Jun 27 11:32:05 2013 From: pbenedict at apache.org (Paul Benedict) Date: Thu, 27 Jun 2013 13:32:05 -0500 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: <51CC810A.8060003@oracle.com> References: <51CC810A.8060003@oracle.com> Message-ID: Brian, if you're focus is 99/100% compatibility, I guess it won't work. However, if you loosen the requirements, it should be possible to overcome the compatibility reasons with this plan: For class files <= 52.0, the JVM will resolve static method inheritance. Otherwise, when code is recompiled for JDK 9+ (>= 53.0), static method inheritence will be rejected. This should be made even easier with the deprecation of --source/--target (JEP 182). If absolute source compatibility is necessary, the source compatibility could be controlled by another JVM option. On Thu, Jun 27, 2013 at 1:14 PM, Brian Goetz wrote: > Total agreement that it was a mistake to have them be inheritable. Static > methods in interfaces don't have this defect. (And we took a hit for that > inconsistency.) Unfortunately what you suggest for 9 is impractical for > compatibility reasons. > > Overall I like Stephen's proposal here (except I am not convinced that it > is suitable for an annotation, but that's a pretty superficial aspect of > it.) Anything that moves us towards being able to fix this problem over > time is good. > > > On 6/27/2013 1:50 PM, Paul Benedict wrote: > >> Stephen, it's an interesting idea. Bikeshed moment.... At the cost of >> having to recompile future code, I'd rather wish to have static methods on >> classes not be inheritable in JDK 9 and onward. Then the same behavior can >> be predictable across classes or interfaces. Fixing a bad language design >> is probably better than patching things up with @NotInherited. >> >> >> On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne >> wrote: >> >> The addition of static methods on interfaces has given developers a >>> new very useful tool. However, it has also produced a dliemma. >>> >>> A static method on a class is accessible/"inherited" by subclasses. >>> Thus SubClass.foo() is just as good as SuperClass.foo() for accessing >>> the static method defined on SuperClass. By contrast, with static >>> methods on interfaces, this is not possible - a static method on an >>> interface is not "inherited" (a Good Thing). >>> >>> The dliemma, from JSR-310 >>> (https://github.com/ThreeTen/**threeten/issues/321), >>> is that I _really_ >>> want to avoid the inheritance of static methods from one abstract >>> class (Chronology), as the methods make no sense at all to be called >>> on the subclasses, and in fact they may cause bugs. Thus, the new >>> language feature pushes me to change the abstract class to be an >>> interface *just to get the new static method behaviour*. In essence I >>> have to make a new trade off between the right tool for the job >>> (abstract class) and the right tool to avoid static method bugs >>> (interface). >>> >>> It occured to me that as this was a new dliemma, I should report it >>> here on lambda-dev. And propose a possible solution. >>> >>> Consider a new annotation @NotInherited that is only applicable to >>> static methods. If a developer places it on a static method, then the >>> method cannot be invoked by subclasses: >>> >>> public class A { >>> @NotInherited >>> public static void foo() {..} >>> } >>> public class B extends A { >>> } >>> { // other code >>> A.foo(); // compiles >>> B.foo(); // would not compile with this proposal >>> } >>> >>> - Many IDEs support something similar today, but this would be >>> enforced at the compiler level. >>> - It is similar to @Override in conceptual scope, and is therefore >>> suitable for an annotation. >>> - It would not change the compiled bytecode at all, other than the >>> standard storage for the additional annotation. >>> - There are no reflection, security or backwards compatibility issues >>> that I can see. >>> - Adding the annotation to a previously published API would be >>> backwards incompatible at the source level, but not the binary level >>> - When compiling B against a previously compiled A, the annotation >>> would be read from A's bytecode. >>> - The annotation would not be processed by the JVM or verifier, thus >>> B.foo() would be valid if it could be compiled (such as in a separate >>> compilation scenario). >>> - The change appears to be small, and thus not require a large effort >>> to implement >>> >>> The annotation could be added to the JDK without enforcing it in >>> javac, but that would seem to be a change not worth doing as it would >>> rely on IDEs. >>> >>> Its easy to say that this is an old problem and so nothing needs to be >>> done. But I hope I've tried to indicate that I think lambda's static >>> methods on interfaces has changed the nature of the old problem and >>> made it potentially more problematic in code design terms. >>> >>> Thoughts? >>> Stephen >>> >>> >>> >> From daniel.latremoliere at gmail.com Thu Jun 27 11:35:37 2013 From: daniel.latremoliere at gmail.com (=?ISO-8859-1?Q?Daniel_Latr=E9moli=E8re?=) Date: Thu, 27 Jun 2013 20:35:37 +0200 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: <51CC810A.8060003@oracle.com> References: <51CC810A.8060003@oracle.com> Message-ID: <51CC85F9.20909@gmail.com> > Anything that moves us towards being able to fix this problem > over time is good. Is a new compiler switch "-nodefaults" possible for helping removal (step by step) of unsuitable Java defaults? In this case, you can call javac with this switch and obtain supplemental errors/warnings for bad behaviour (default constructor, default imports, static method call for superclass, etc.). From brian.goetz at oracle.com Thu Jun 27 11:36:47 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Thu, 27 Jun 2013 14:36:47 -0400 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: References: <51CC810A.8060003@oracle.com> Message-ID: <51CC863F.6080800@oracle.com> I got what you were saying. What I was telling you is that our compatibility goals are higher than that, and that at the very least it would take probably 2-3 major versions, even if we were willing to do this. We have a very limited budget for this kind of incompatibility; we want to spend it where it will provide the most payoff. Here, our excuse is pretty lame: "we think Java should have been designed the other way, so we're changing it." That's just a silly thing to spend our incompatibility budget on. (And I agree with you that this language feature was a mistake.) On 6/27/2013 2:32 PM, Paul Benedict wrote: > Brian, if you're focus is 99/100% compatibility, I guess it won't work. > However, if you loosen the requirements, it should be possible to > overcome the compatibility reasons with this plan: > > For class files <= 52.0, the JVM will resolve static method inheritance. > Otherwise, when code is recompiled for JDK 9+ (>= 53.0), static method > inheritence will be rejected. This should be made even easier with the > deprecation of --source/--target (JEP 182). If absolute source > compatibility is necessary, the source compatibility could be controlled > by another JVM option. > > > On Thu, Jun 27, 2013 at 1:14 PM, Brian Goetz > wrote: > > Total agreement that it was a mistake to have them be inheritable. > Static methods in interfaces don't have this defect. (And we took a > hit for that inconsistency.) Unfortunately what you suggest for 9 > is impractical for compatibility reasons. > > Overall I like Stephen's proposal here (except I am not convinced > that it is suitable for an annotation, but that's a pretty > superficial aspect of it.) Anything that moves us towards being > able to fix this problem over time is good. > > > On 6/27/2013 1:50 PM, Paul Benedict wrote: > > Stephen, it's an interesting idea. Bikeshed moment.... At the > cost of > having to recompile future code, I'd rather wish to have static > methods on > classes not be inheritable in JDK 9 and onward. Then the same > behavior can > be predictable across classes or interfaces. Fixing a bad > language design > is probably better than patching things up with @NotInherited. > > > On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne > >wrote: > > The addition of static methods on interfaces has given > developers a > new very useful tool. However, it has also produced a dliemma. > > A static method on a class is accessible/"inherited" by > subclasses. > Thus SubClass.foo() is just as good as SuperClass.foo() for > accessing > the static method defined on SuperClass. By contrast, with > static > methods on interfaces, this is not possible - a static > method on an > interface is not "inherited" (a Good Thing). > > The dliemma, from JSR-310 > (https://github.com/ThreeTen/__threeten/issues/321 > ), is that > I _really_ > want to avoid the inheritance of static methods from one > abstract > class (Chronology), as the methods make no sense at all to > be called > on the subclasses, and in fact they may cause bugs. Thus, > the new > language feature pushes me to change the abstract class to be an > interface *just to get the new static method behaviour*. In > essence I > have to make a new trade off between the right tool for the job > (abstract class) and the right tool to avoid static method bugs > (interface). > > It occured to me that as this was a new dliemma, I should > report it > here on lambda-dev. And propose a possible solution. > > Consider a new annotation @NotInherited that is only > applicable to > static methods. If a developer places it on a static method, > then the > method cannot be invoked by subclasses: > > public class A { > @NotInherited > public static void foo() {..} > } > public class B extends A { > } > { // other code > A.foo(); // compiles > B.foo(); // would not compile with this proposal > } > > - Many IDEs support something similar today, but this would be > enforced at the compiler level. > - It is similar to @Override in conceptual scope, and is > therefore > suitable for an annotation. > - It would not change the compiled bytecode at all, other > than the > standard storage for the additional annotation. > - There are no reflection, security or backwards > compatibility issues > that I can see. > - Adding the annotation to a previously published API would be > backwards incompatible at the source level, but not the > binary level > - When compiling B against a previously compiled A, the > annotation > would be read from A's bytecode. > - The annotation would not be processed by the JVM or > verifier, thus > B.foo() would be valid if it could be compiled (such as in a > separate > compilation scenario). > - The change appears to be small, and thus not require a > large effort > to implement > > The annotation could be added to the JDK without enforcing it in > javac, but that would seem to be a change not worth doing as > it would > rely on IDEs. > > Its easy to say that this is an old problem and so nothing > needs to be > done. But I hope I've tried to indicate that I think > lambda's static > methods on interfaces has changed the nature of the old > problem and > made it potentially more problematic in code design terms. > > Thoughts? > Stephen > > > > From pbenedict at apache.org Thu Jun 27 11:49:06 2013 From: pbenedict at apache.org (Paul Benedict) Date: Thu, 27 Jun 2013 13:49:06 -0500 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: <51CC863F.6080800@oracle.com> References: <51CC810A.8060003@oracle.com> <51CC863F.6080800@oracle.com> Message-ID: If neither an annotation nor grammar change is appropriate, I am puzzled by what remaining option could exist. On Thu, Jun 27, 2013 at 1:36 PM, Brian Goetz wrote: > I got what you were saying. What I was telling you is that our > compatibility goals are higher than that, and that at the very least it > would take probably 2-3 major versions, even if we were willing to do this. > We have a very limited budget for this kind of incompatibility; we want to > spend it where it will provide the most payoff. Here, our excuse is pretty > lame: "we think Java should have been designed the other way, so we're > changing it." That's just a silly thing to spend our incompatibility > budget on. (And I agree with you that this language feature was a mistake.) > > > > > On 6/27/2013 2:32 PM, Paul Benedict wrote: > >> Brian, if you're focus is 99/100% compatibility, I guess it won't work. >> However, if you loosen the requirements, it should be possible to >> overcome the compatibility reasons with this plan: >> >> For class files <= 52.0, the JVM will resolve static method inheritance. >> Otherwise, when code is recompiled for JDK 9+ (>= 53.0), static method >> inheritence will be rejected. This should be made even easier with the >> deprecation of --source/--target (JEP 182). If absolute source >> compatibility is necessary, the source compatibility could be controlled >> by another JVM option. >> >> >> On Thu, Jun 27, 2013 at 1:14 PM, Brian Goetz > > wrote: >> >> Total agreement that it was a mistake to have them be inheritable. >> Static methods in interfaces don't have this defect. (And we took a >> hit for that inconsistency.) Unfortunately what you suggest for 9 >> is impractical for compatibility reasons. >> >> Overall I like Stephen's proposal here (except I am not convinced >> that it is suitable for an annotation, but that's a pretty >> superficial aspect of it.) Anything that moves us towards being >> able to fix this problem over time is good. >> >> >> On 6/27/2013 1:50 PM, Paul Benedict wrote: >> >> Stephen, it's an interesting idea. Bikeshed moment.... At the >> cost of >> having to recompile future code, I'd rather wish to have static >> methods on >> classes not be inheritable in JDK 9 and onward. Then the same >> behavior can >> be predictable across classes or interfaces. Fixing a bad >> language design >> is probably better than patching things up with @NotInherited. >> >> >> On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne >> >**wrote: >> >> >> The addition of static methods on interfaces has given >> developers a >> new very useful tool. However, it has also produced a dliemma. >> >> A static method on a class is accessible/"inherited" by >> subclasses. >> Thus SubClass.foo() is just as good as SuperClass.foo() for >> accessing >> the static method defined on SuperClass. By contrast, with >> static >> methods on interfaces, this is not possible - a static >> method on an >> interface is not "inherited" (a Good Thing). >> >> The dliemma, from JSR-310 >> (https://github.com/ThreeTen/_**_threeten/issues/321 >> >), >> is that >> >> I _really_ >> want to avoid the inheritance of static methods from one >> abstract >> class (Chronology), as the methods make no sense at all to >> be called >> on the subclasses, and in fact they may cause bugs. Thus, >> the new >> language feature pushes me to change the abstract class to be >> an >> interface *just to get the new static method behaviour*. In >> essence I >> have to make a new trade off between the right tool for the >> job >> (abstract class) and the right tool to avoid static method >> bugs >> (interface). >> >> It occured to me that as this was a new dliemma, I should >> report it >> here on lambda-dev. And propose a possible solution. >> >> Consider a new annotation @NotInherited that is only >> applicable to >> static methods. If a developer places it on a static method, >> then the >> method cannot be invoked by subclasses: >> >> public class A { >> @NotInherited >> public static void foo() {..} >> } >> public class B extends A { >> } >> { // other code >> A.foo(); // compiles >> B.foo(); // would not compile with this proposal >> } >> >> - Many IDEs support something similar today, but this would be >> enforced at the compiler level. >> - It is similar to @Override in conceptual scope, and is >> therefore >> suitable for an annotation. >> - It would not change the compiled bytecode at all, other >> than the >> standard storage for the additional annotation. >> - There are no reflection, security or backwards >> compatibility issues >> that I can see. >> - Adding the annotation to a previously published API would be >> backwards incompatible at the source level, but not the >> binary level >> - When compiling B against a previously compiled A, the >> annotation >> would be read from A's bytecode. >> - The annotation would not be processed by the JVM or >> verifier, thus >> B.foo() would be valid if it could be compiled (such as in a >> separate >> compilation scenario). >> - The change appears to be small, and thus not require a >> large effort >> to implement >> >> The annotation could be added to the JDK without enforcing it >> in >> javac, but that would seem to be a change not worth doing as >> it would >> rely on IDEs. >> >> Its easy to say that this is an old problem and so nothing >> needs to be >> done. But I hope I've tried to indicate that I think >> lambda's static >> methods on interfaces has changed the nature of the old >> problem and >> made it potentially more problematic in code design terms. >> >> Thoughts? >> Stephen >> >> >> >> >> From jonathan.gibbons at oracle.com Thu Jun 27 11:53:54 2013 From: jonathan.gibbons at oracle.com (Jonathan Gibbons) Date: Thu, 27 Jun 2013 11:53:54 -0700 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: <51CC863F.6080800@oracle.com> References: <51CC810A.8060003@oracle.com> <51CC863F.6080800@oracle.com> Message-ID: <51CC8A42.60306@oracle.com> It would be reasonable to add a lint warning in the [static] category in situations where a static method is invoked through a subclass. We already warn in cases where a static method is invoked through an instance of a class. -- Jon On 06/27/2013 11:36 AM, Brian Goetz wrote: > I got what you were saying. What I was telling you is that our > compatibility goals are higher than that, and that at the very least it > would take probably 2-3 major versions, even if we were willing to do > this. We have a very limited budget for this kind of incompatibility; > we want to spend it where it will provide the most payoff. Here, our > excuse is pretty lame: "we think Java should have been designed the > other way, so we're changing it." That's just a silly thing to spend > our incompatibility budget on. (And I agree with you that this language > feature was a mistake.) > > > > On 6/27/2013 2:32 PM, Paul Benedict wrote: >> Brian, if you're focus is 99/100% compatibility, I guess it won't work. >> However, if you loosen the requirements, it should be possible to >> overcome the compatibility reasons with this plan: >> >> For class files <= 52.0, the JVM will resolve static method inheritance. >> Otherwise, when code is recompiled for JDK 9+ (>= 53.0), static method >> inheritence will be rejected. This should be made even easier with the >> deprecation of --source/--target (JEP 182). If absolute source >> compatibility is necessary, the source compatibility could be controlled >> by another JVM option. >> >> >> On Thu, Jun 27, 2013 at 1:14 PM, Brian Goetz > > wrote: >> >> Total agreement that it was a mistake to have them be inheritable. >> Static methods in interfaces don't have this defect. (And we took a >> hit for that inconsistency.) Unfortunately what you suggest for 9 >> is impractical for compatibility reasons. >> >> Overall I like Stephen's proposal here (except I am not convinced >> that it is suitable for an annotation, but that's a pretty >> superficial aspect of it.) Anything that moves us towards being >> able to fix this problem over time is good. >> >> >> On 6/27/2013 1:50 PM, Paul Benedict wrote: >> >> Stephen, it's an interesting idea. Bikeshed moment.... At the >> cost of >> having to recompile future code, I'd rather wish to have static >> methods on >> classes not be inheritable in JDK 9 and onward. Then the same >> behavior can >> be predictable across classes or interfaces. Fixing a bad >> language design >> is probably better than patching things up with @NotInherited. >> >> >> On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne >> >wrote: >> >> The addition of static methods on interfaces has given >> developers a >> new very useful tool. However, it has also produced a dliemma. >> >> A static method on a class is accessible/"inherited" by >> subclasses. >> Thus SubClass.foo() is just as good as SuperClass.foo() for >> accessing >> the static method defined on SuperClass. By contrast, with >> static >> methods on interfaces, this is not possible - a static >> method on an >> interface is not "inherited" (a Good Thing). >> >> The dliemma, from JSR-310 >> (https://github.com/ThreeTen/__threeten/issues/321 >> ), is that >> I _really_ >> want to avoid the inheritance of static methods from one >> abstract >> class (Chronology), as the methods make no sense at all to >> be called >> on the subclasses, and in fact they may cause bugs. Thus, >> the new >> language feature pushes me to change the abstract class to be an >> interface *just to get the new static method behaviour*. In >> essence I >> have to make a new trade off between the right tool for the job >> (abstract class) and the right tool to avoid static method bugs >> (interface). >> >> It occured to me that as this was a new dliemma, I should >> report it >> here on lambda-dev. And propose a possible solution. >> >> Consider a new annotation @NotInherited that is only >> applicable to >> static methods. If a developer places it on a static method, >> then the >> method cannot be invoked by subclasses: >> >> public class A { >> @NotInherited >> public static void foo() {..} >> } >> public class B extends A { >> } >> { // other code >> A.foo(); // compiles >> B.foo(); // would not compile with this proposal >> } >> >> - Many IDEs support something similar today, but this would be >> enforced at the compiler level. >> - It is similar to @Override in conceptual scope, and is >> therefore >> suitable for an annotation. >> - It would not change the compiled bytecode at all, other >> than the >> standard storage for the additional annotation. >> - There are no reflection, security or backwards >> compatibility issues >> that I can see. >> - Adding the annotation to a previously published API would be >> backwards incompatible at the source level, but not the >> binary level >> - When compiling B against a previously compiled A, the >> annotation >> would be read from A's bytecode. >> - The annotation would not be processed by the JVM or >> verifier, thus >> B.foo() would be valid if it could be compiled (such as in a >> separate >> compilation scenario). >> - The change appears to be small, and thus not require a >> large effort >> to implement >> >> The annotation could be added to the JDK without enforcing it in >> javac, but that would seem to be a change not worth doing as >> it would >> rely on IDEs. >> >> Its easy to say that this is an old problem and so nothing >> needs to be >> done. But I hope I've tried to indicate that I think >> lambda's static >> methods on interfaces has changed the nature of the old >> problem and >> made it potentially more problematic in code design terms. >> >> Thoughts? >> Stephen >> >> >> >> From brian.goetz at oracle.com Thu Jun 27 11:58:29 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Thu, 27 Jun 2013 14:58:29 -0400 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: References: <51CC810A.8060003@oracle.com> <51CC863F.6080800@oracle.com> Message-ID: <51CC8B55.7010003@oracle.com> Stephen's proposal is workable with a language change; it is a way for the developer to say "I intend this method to not be inherited". (One could have an angels-on-head-of-pin argument about whether an annotation is OK here, but that's a pretty minor part of the story so no point in having it now.) We have no problem with considering features that make it harder for people to make mistakes, or to give users more control, presuming that they carry their weight. What's mostly impractical was the additional suggestion to change the meaning of existing Java code because we don't like the language design choices that were made in 1997. On 6/27/2013 2:49 PM, Paul Benedict wrote: > If neither an annotation nor grammar change is appropriate, I am puzzled > by what remaining option could exist. > > > On Thu, Jun 27, 2013 at 1:36 PM, Brian Goetz > wrote: > > I got what you were saying. What I was telling you is that our > compatibility goals are higher than that, and that at the very least > it would take probably 2-3 major versions, even if we were willing > to do this. We have a very limited budget for this kind of > incompatibility; we want to spend it where it will provide the most > payoff. Here, our excuse is pretty lame: "we think Java should have > been designed the other way, so we're changing it." That's just a > silly thing to spend our incompatibility budget on. (And I agree > with you that this language feature was a mistake.) > > > > > On 6/27/2013 2:32 PM, Paul Benedict wrote: > > Brian, if you're focus is 99/100% compatibility, I guess it > won't work. > However, if you loosen the requirements, it should be possible to > overcome the compatibility reasons with this plan: > > For class files <= 52.0, the JVM will resolve static method > inheritance. > Otherwise, when code is recompiled for JDK 9+ (>= 53.0), static > method > inheritence will be rejected. This should be made even easier > with the > deprecation of --source/--target (JEP 182). If absolute source > compatibility is necessary, the source compatibility could be > controlled > by another JVM option. > > > On Thu, Jun 27, 2013 at 1:14 PM, Brian Goetz > > __>> wrote: > > Total agreement that it was a mistake to have them be > inheritable. > Static methods in interfaces don't have this defect. (And > we took a > hit for that inconsistency.) Unfortunately what you > suggest for 9 > is impractical for compatibility reasons. > > Overall I like Stephen's proposal here (except I am not > convinced > that it is suitable for an annotation, but that's a pretty > superficial aspect of it.) Anything that moves us towards > being > able to fix this problem over time is good. > > > On 6/27/2013 1:50 PM, Paul Benedict wrote: > > Stephen, it's an interesting idea. Bikeshed moment.... > At the > cost of > having to recompile future code, I'd rather wish to > have static > methods on > classes not be inheritable in JDK 9 and onward. Then > the same > behavior can > be predictable across classes or interfaces. Fixing a bad > language design > is probably better than patching things up with > @NotInherited. > > > On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne > > >>__wrote: > > > The addition of static methods on interfaces has given > developers a > new very useful tool. However, it has also produced > a dliemma. > > A static method on a class is accessible/"inherited" by > subclasses. > Thus SubClass.foo() is just as good as > SuperClass.foo() for > accessing > the static method defined on SuperClass. By > contrast, with > static > methods on interfaces, this is not possible - a static > method on an > interface is not "inherited" (a Good Thing). > > The dliemma, from JSR-310 > > (https://github.com/ThreeTen/____threeten/issues/321 > > >), is that > > I _really_ > want to avoid the inheritance of static methods > from one > abstract > class (Chronology), as the methods make no sense at > all to > be called > on the subclasses, and in fact they may cause bugs. > Thus, > the new > language feature pushes me to change the abstract > class to be an > interface *just to get the new static method > behaviour*. In > essence I > have to make a new trade off between the right tool > for the job > (abstract class) and the right tool to avoid static > method bugs > (interface). > > It occured to me that as this was a new dliemma, I > should > report it > here on lambda-dev. And propose a possible solution. > > Consider a new annotation @NotInherited that is only > applicable to > static methods. If a developer places it on a > static method, > then the > method cannot be invoked by subclasses: > > public class A { > @NotInherited > public static void foo() {..} > } > public class B extends A { > } > { // other code > A.foo(); // compiles > B.foo(); // would not compile with this proposal > } > > - Many IDEs support something similar today, but > this would be > enforced at the compiler level. > - It is similar to @Override in conceptual scope, > and is > therefore > suitable for an annotation. > - It would not change the compiled bytecode at all, > other > than the > standard storage for the additional annotation. > - There are no reflection, security or backwards > compatibility issues > that I can see. > - Adding the annotation to a previously published > API would be > backwards incompatible at the source level, but not the > binary level > - When compiling B against a previously compiled A, the > annotation > would be read from A's bytecode. > - The annotation would not be processed by the JVM or > verifier, thus > B.foo() would be valid if it could be compiled > (such as in a > separate > compilation scenario). > - The change appears to be small, and thus not > require a > large effort > to implement > > The annotation could be added to the JDK without > enforcing it in > javac, but that would seem to be a change not worth > doing as > it would > rely on IDEs. > > Its easy to say that this is an old problem and so > nothing > needs to be > done. But I hope I've tried to indicate that I think > lambda's static > methods on interfaces has changed the nature of the old > problem and > made it potentially more problematic in code design > terms. > > Thoughts? > Stephen > > > > > From brian.goetz at oracle.com Thu Jun 27 12:01:07 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Thu, 27 Jun 2013 15:01:07 -0400 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: <51CC85F9.20909@gmail.com> References: <51CC810A.8060003@oracle.com> <51CC85F9.20909@gmail.com> Message-ID: <51CC8BF3.80805@oracle.com> Definitely not. We don't add language features via (implementation-specific) compiler switches! I don't disagree that there may be times when finer control over default inheritance is desirable (though that's a completely separate issue than the one being discussed on this thread.) Its just that adding compiler switches is not how we'd consider doing that. On 6/27/2013 2:35 PM, Daniel Latr?moli?re wrote: > >> Anything that moves us towards being able to fix this problem >> over time is good. > Is a new compiler switch "-nodefaults" possible for helping removal > (step by step) of unsuitable Java defaults? > > In this case, you can call javac with this switch and obtain > supplemental errors/warnings for bad behaviour (default constructor, > default imports, static method call for superclass, etc.). > > From nicholas+openjdk at nicholaswilliams.net Thu Jun 27 12:13:26 2013 From: nicholas+openjdk at nicholaswilliams.net (Nick Williams) Date: Thu, 27 Jun 2013 14:13:26 -0500 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: <51CC8BF3.80805@oracle.com> References: <51CC810A.8060003@oracle.com> <51CC85F9.20909@gmail.com> <51CC8BF3.80805@oracle.com> Message-ID: <8AEA6380-83E9-49E4-9B7F-C115638CA31B@nicholaswilliams.net> What about something like this (as an alternative to an annotation): public static local void myMethod(String arg1, Object arg2, etc.) { } I recognize that a new keyword is a more involved change than an annotation, but it also "feels" more right (to me), and an alternative was solicited. "local" might not be the best keyword, but it's the first thing that came to mind, and I like it. Just a thought. Nick On Jun 27, 2013, at 2:01 PM, Brian Goetz wrote: > Definitely not. We don't add language features via > (implementation-specific) compiler switches! > > I don't disagree that there may be times when finer control over default > inheritance is desirable (though that's a completely separate issue than > the one being discussed on this thread.) Its just that adding compiler > switches is not how we'd consider doing that. > > On 6/27/2013 2:35 PM, Daniel Latr?moli?re wrote: >> >>> Anything that moves us towards being able to fix this problem >>> over time is good. >> Is a new compiler switch "-nodefaults" possible for helping removal >> (step by step) of unsuitable Java defaults? >> >> In this case, you can call javac with this switch and obtain >> supplemental errors/warnings for bad behaviour (default constructor, >> default imports, static method call for superclass, etc.). >> >> > From brian at briangoetz.com Thu Jun 27 12:22:58 2013 From: brian at briangoetz.com (Brian Goetz) Date: Thu, 27 Jun 2013 15:22:58 -0400 Subject: RFR: SpliteratorCollections test patch Message-ID: <51CC9112.7070606@briangoetz.com> Please review: diff --git a/test/java/util/Spliterator/SpliteratorCollisions.java b/test/java/util/Spliterator/SpliteratorCollisions.java --- a/test/java/util/Spliterator/SpliteratorCollisions.java +++ b/test/java/util/Spliterator/SpliteratorCollisions.java @@ -148,7 +148,6 @@ List data = new ArrayList<>(); for (int size : SIZES) { List exp = listIntRange(size, true); - exp.add(0, null); SpliteratorDataBuilder db = new SpliteratorDataBuilder<>(data, exp); // Maps I think the exp.add() line is redundant (triggered by withNull=true in listIntRange call) and is causing UOEs because listIntRange returns an unmodifiable list. From forax at univ-mlv.fr Thu Jun 27 14:04:51 2013 From: forax at univ-mlv.fr (Remi Forax) Date: Thu, 27 Jun 2013 23:04:51 +0200 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: <51CC8A42.60306@oracle.com> References: <51CC810A.8060003@oracle.com> <51CC863F.6080800@oracle.com> <51CC8A42.60306@oracle.com> Message-ID: <51CCA8F3.5040005@univ-mlv.fr> On 06/27/2013 08:53 PM, Jonathan Gibbons wrote: > It would be reasonable to add a lint warning in the [static] category > in situations where a static method is invoked through a subclass. > We already warn in cases where a static method is invoked through > an instance of a class. > > -- Jon yes, I know that Eclipse, at least, already proposes this warning. R?mi > > On 06/27/2013 11:36 AM, Brian Goetz wrote: >> I got what you were saying. What I was telling you is that our >> compatibility goals are higher than that, and that at the very least it >> would take probably 2-3 major versions, even if we were willing to do >> this. We have a very limited budget for this kind of incompatibility; >> we want to spend it where it will provide the most payoff. Here, our >> excuse is pretty lame: "we think Java should have been designed the >> other way, so we're changing it." That's just a silly thing to spend >> our incompatibility budget on. (And I agree with you that this language >> feature was a mistake.) >> >> >> >> On 6/27/2013 2:32 PM, Paul Benedict wrote: >>> Brian, if you're focus is 99/100% compatibility, I guess it won't work. >>> However, if you loosen the requirements, it should be possible to >>> overcome the compatibility reasons with this plan: >>> >>> For class files <= 52.0, the JVM will resolve static method inheritance. >>> Otherwise, when code is recompiled for JDK 9+ (>= 53.0), static method >>> inheritence will be rejected. This should be made even easier with the >>> deprecation of --source/--target (JEP 182). If absolute source >>> compatibility is necessary, the source compatibility could be controlled >>> by another JVM option. >>> >>> >>> On Thu, Jun 27, 2013 at 1:14 PM, Brian Goetz >> > wrote: >>> >>> Total agreement that it was a mistake to have them be inheritable. >>> Static methods in interfaces don't have this defect. (And we took a >>> hit for that inconsistency.) Unfortunately what you suggest for 9 >>> is impractical for compatibility reasons. >>> >>> Overall I like Stephen's proposal here (except I am not convinced >>> that it is suitable for an annotation, but that's a pretty >>> superficial aspect of it.) Anything that moves us towards being >>> able to fix this problem over time is good. >>> >>> >>> On 6/27/2013 1:50 PM, Paul Benedict wrote: >>> >>> Stephen, it's an interesting idea. Bikeshed moment.... At the >>> cost of >>> having to recompile future code, I'd rather wish to have static >>> methods on >>> classes not be inheritable in JDK 9 and onward. Then the same >>> behavior can >>> be predictable across classes or interfaces. Fixing a bad >>> language design >>> is probably better than patching things up with @NotInherited. >>> >>> >>> On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne >>> >wrote: >>> >>> The addition of static methods on interfaces has given >>> developers a >>> new very useful tool. However, it has also produced a dliemma. >>> >>> A static method on a class is accessible/"inherited" by >>> subclasses. >>> Thus SubClass.foo() is just as good as SuperClass.foo() for >>> accessing >>> the static method defined on SuperClass. By contrast, with >>> static >>> methods on interfaces, this is not possible - a static >>> method on an >>> interface is not "inherited" (a Good Thing). >>> >>> The dliemma, from JSR-310 >>> (https://github.com/ThreeTen/__threeten/issues/321 >>> ), is that >>> I _really_ >>> want to avoid the inheritance of static methods from one >>> abstract >>> class (Chronology), as the methods make no sense at all to >>> be called >>> on the subclasses, and in fact they may cause bugs. Thus, >>> the new >>> language feature pushes me to change the abstract class to be an >>> interface *just to get the new static method behaviour*. In >>> essence I >>> have to make a new trade off between the right tool for the job >>> (abstract class) and the right tool to avoid static method bugs >>> (interface). >>> >>> It occured to me that as this was a new dliemma, I should >>> report it >>> here on lambda-dev. And propose a possible solution. >>> >>> Consider a new annotation @NotInherited that is only >>> applicable to >>> static methods. If a developer places it on a static method, >>> then the >>> method cannot be invoked by subclasses: >>> >>> public class A { >>> @NotInherited >>> public static void foo() {..} >>> } >>> public class B extends A { >>> } >>> { // other code >>> A.foo(); // compiles >>> B.foo(); // would not compile with this proposal >>> } >>> >>> - Many IDEs support something similar today, but this would be >>> enforced at the compiler level. >>> - It is similar to @Override in conceptual scope, and is >>> therefore >>> suitable for an annotation. >>> - It would not change the compiled bytecode at all, other >>> than the >>> standard storage for the additional annotation. >>> - There are no reflection, security or backwards >>> compatibility issues >>> that I can see. >>> - Adding the annotation to a previously published API would be >>> backwards incompatible at the source level, but not the >>> binary level >>> - When compiling B against a previously compiled A, the >>> annotation >>> would be read from A's bytecode. >>> - The annotation would not be processed by the JVM or >>> verifier, thus >>> B.foo() would be valid if it could be compiled (such as in a >>> separate >>> compilation scenario). >>> - The change appears to be small, and thus not require a >>> large effort >>> to implement >>> >>> The annotation could be added to the JDK without enforcing it in >>> javac, but that would seem to be a change not worth doing as >>> it would >>> rely on IDEs. >>> >>> Its easy to say that this is an old problem and so nothing >>> needs to be >>> done. But I hope I've tried to indicate that I think >>> lambda's static >>> methods on interfaces has changed the nature of the old >>> problem and >>> made it potentially more problematic in code design terms. >>> >>> Thoughts? >>> Stephen >>> >>> >>> >>> > From zhong.j.yu at gmail.com Thu Jun 27 14:17:37 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Thu, 27 Jun 2013 16:17:37 -0500 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: References: Message-ID: Stephen, would it be more accurate to say that what you want is actually non-"overridable". It's not a problem that B inherits foo() from A. It is a problem that B may introduce its own foo(), therefore the meaning of `B.foo()` is a little uncertain. Non-overridable can be achieved by "final" on instance methods. For static methods, oddly enough, "final" has the same effect - it prevents subclass to introduce a method with the same signature - http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.3.3 It is a compile-time error to attempt to override or hide a final method. http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.8.2 If a class declares a static method m, then the declaration m is said to hide any method m', where the signature of m is a subsignature (?8.4.2) of the signature of m', in the superclasses and superinterfaces of the class that would otherwise be accessible to code in the class. Therefore if we have class A final static void foo(){} class B static void foo(){} B should not compile. (Unfortunately, it does compile in javac 7. A bug?) So can we say "final" static method already does what you want to achieve? Zhong Yu From zhong.j.yu at gmail.com Thu Jun 27 14:22:48 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Thu, 27 Jun 2013 16:22:48 -0500 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: References: Message-ID: On Thu, Jun 27, 2013 at 4:17 PM, Zhong Yu wrote: > Stephen, would it be more accurate to say that what you want is > actually non-"overridable". It's not a problem that B inherits foo() > from A. It is a problem that B may introduce its own foo(), therefore > the meaning of `B.foo()` is a little uncertain. > > Non-overridable can be achieved by "final" on instance methods. > > For static methods, oddly enough, "final" has the same effect - it > prevents subclass to introduce a method with the same signature - > > http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.3.3 > > It is a compile-time error to attempt to override or hide a final method. > > http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.8.2 > > If a class declares a static method m, then the declaration m is said > to hide any method m', where the signature of m is a subsignature > (?8.4.2) of the signature of m', in the superclasses and > superinterfaces of the class that would otherwise be accessible to > code in the class. > > Therefore if we have > > class A > > final static void foo(){} > > class B > > static void foo(){} > > B should not compile. (Unfortunately, it does compile in javac 7. A bug?) Sorry, the example should say class B extends A and it indeed does not compile in javac 7, hurray - error: foo() in B cannot override foo() in A, overridden method is static,final > > So can we say "final" static method already does what you want to achieve? > > > Zhong Yu From scolebourne at joda.org Thu Jun 27 15:42:38 2013 From: scolebourne at joda.org (Stephen Colebourne) Date: Thu, 27 Jun 2013 23:42:38 +0100 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: References: Message-ID: On 27 June 2013 22:17, Zhong Yu wrote: > Stephen, would it be more accurate to say that what you want is > actually non-"overridable". It's not a problem that B inherits foo() > from A. It is a problem that B may introduce its own foo(), therefore > the meaning of `B.foo()` is a little uncertain. No, its specifically that anyone reading B.foo() instead of A.foo() would/could misunderstand what the code meant. I actually made the mistake myself, ie.with my own API. My call wasn't type checked because it was being directly passed to an assertEquals(Object,Object) in a test case. Stephen From scolebourne at joda.org Thu Jun 27 15:45:49 2013 From: scolebourne at joda.org (Stephen Colebourne) Date: Thu, 27 Jun 2013 23:45:49 +0100 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: <51CC8A42.60306@oracle.com> References: <51CC810A.8060003@oracle.com> <51CC863F.6080800@oracle.com> <51CC8A42.60306@oracle.com> Message-ID: This sounds like a good start. Really, IDEs should stop offering B.foo() as their default setup. The annotation/keyword is just the extra step to enforce that at the users behest. Stephen On 27 June 2013 19:53, Jonathan Gibbons wrote: > It would be reasonable to add a lint warning in the [static] category > in situations where a static method is invoked through a subclass. > We already warn in cases where a static method is invoked through > an instance of a class. > > -- Jon > > On 06/27/2013 11:36 AM, Brian Goetz wrote: >> I got what you were saying. What I was telling you is that our >> compatibility goals are higher than that, and that at the very least it >> would take probably 2-3 major versions, even if we were willing to do >> this. We have a very limited budget for this kind of incompatibility; >> we want to spend it where it will provide the most payoff. Here, our >> excuse is pretty lame: "we think Java should have been designed the >> other way, so we're changing it." That's just a silly thing to spend >> our incompatibility budget on. (And I agree with you that this language >> feature was a mistake.) >> >> >> >> On 6/27/2013 2:32 PM, Paul Benedict wrote: >>> Brian, if you're focus is 99/100% compatibility, I guess it won't work. >>> However, if you loosen the requirements, it should be possible to >>> overcome the compatibility reasons with this plan: >>> >>> For class files <= 52.0, the JVM will resolve static method inheritance. >>> Otherwise, when code is recompiled for JDK 9+ (>= 53.0), static method >>> inheritence will be rejected. This should be made even easier with the >>> deprecation of --source/--target (JEP 182). If absolute source >>> compatibility is necessary, the source compatibility could be controlled >>> by another JVM option. >>> >>> >>> On Thu, Jun 27, 2013 at 1:14 PM, Brian Goetz >> > wrote: >>> >>> Total agreement that it was a mistake to have them be inheritable. >>> Static methods in interfaces don't have this defect. (And we took a >>> hit for that inconsistency.) Unfortunately what you suggest for 9 >>> is impractical for compatibility reasons. >>> >>> Overall I like Stephen's proposal here (except I am not convinced >>> that it is suitable for an annotation, but that's a pretty >>> superficial aspect of it.) Anything that moves us towards being >>> able to fix this problem over time is good. >>> >>> >>> On 6/27/2013 1:50 PM, Paul Benedict wrote: >>> >>> Stephen, it's an interesting idea. Bikeshed moment.... At the >>> cost of >>> having to recompile future code, I'd rather wish to have static >>> methods on >>> classes not be inheritable in JDK 9 and onward. Then the same >>> behavior can >>> be predictable across classes or interfaces. Fixing a bad >>> language design >>> is probably better than patching things up with @NotInherited. >>> >>> >>> On Thu, Jun 27, 2013 at 12:20 PM, Stephen Colebourne >>> >wrote: >>> >>> The addition of static methods on interfaces has given >>> developers a >>> new very useful tool. However, it has also produced a dliemma. >>> >>> A static method on a class is accessible/"inherited" by >>> subclasses. >>> Thus SubClass.foo() is just as good as SuperClass.foo() for >>> accessing >>> the static method defined on SuperClass. By contrast, with >>> static >>> methods on interfaces, this is not possible - a static >>> method on an >>> interface is not "inherited" (a Good Thing). >>> >>> The dliemma, from JSR-310 >>> (https://github.com/ThreeTen/__threeten/issues/321 >>> ), is that >>> I _really_ >>> want to avoid the inheritance of static methods from one >>> abstract >>> class (Chronology), as the methods make no sense at all to >>> be called >>> on the subclasses, and in fact they may cause bugs. Thus, >>> the new >>> language feature pushes me to change the abstract class to be an >>> interface *just to get the new static method behaviour*. In >>> essence I >>> have to make a new trade off between the right tool for the job >>> (abstract class) and the right tool to avoid static method bugs >>> (interface). >>> >>> It occured to me that as this was a new dliemma, I should >>> report it >>> here on lambda-dev. And propose a possible solution. >>> >>> Consider a new annotation @NotInherited that is only >>> applicable to >>> static methods. If a developer places it on a static method, >>> then the >>> method cannot be invoked by subclasses: >>> >>> public class A { >>> @NotInherited >>> public static void foo() {..} >>> } >>> public class B extends A { >>> } >>> { // other code >>> A.foo(); // compiles >>> B.foo(); // would not compile with this proposal >>> } >>> >>> - Many IDEs support something similar today, but this would be >>> enforced at the compiler level. >>> - It is similar to @Override in conceptual scope, and is >>> therefore >>> suitable for an annotation. >>> - It would not change the compiled bytecode at all, other >>> than the >>> standard storage for the additional annotation. >>> - There are no reflection, security or backwards >>> compatibility issues >>> that I can see. >>> - Adding the annotation to a previously published API would be >>> backwards incompatible at the source level, but not the >>> binary level >>> - When compiling B against a previously compiled A, the >>> annotation >>> would be read from A's bytecode. >>> - The annotation would not be processed by the JVM or >>> verifier, thus >>> B.foo() would be valid if it could be compiled (such as in a >>> separate >>> compilation scenario). >>> - The change appears to be small, and thus not require a >>> large effort >>> to implement >>> >>> The annotation could be added to the JDK without enforcing it in >>> javac, but that would seem to be a change not worth doing as >>> it would >>> rely on IDEs. >>> >>> Its easy to say that this is an old problem and so nothing >>> needs to be >>> done. But I hope I've tried to indicate that I think >>> lambda's static >>> methods on interfaces has changed the nature of the old >>> problem and >>> made it potentially more problematic in code design terms. >>> >>> Thoughts? >>> Stephen >>> >>> >>> >>> > > From zhong.j.yu at gmail.com Thu Jun 27 17:26:24 2013 From: zhong.j.yu at gmail.com (Zhong Yu) Date: Thu, 27 Jun 2013 19:26:24 -0500 Subject: Static method access dilemma and proposal: @NotInherited In-Reply-To: References: Message-ID: I see, the short name of the method must be prefixed with another word (the class name) to make sense, so inheritance could be very misleading. But if inheritance is considered bad across the board for several different reasons, we shouldn't need explicit flags to disable individual methods; I agree with using javac warning and IDE error to effectively/practically disable this language feature outright. The burden is on those who want to suppress the warning. On Thu, Jun 27, 2013 at 5:42 PM, Stephen Colebourne wrote: > On 27 June 2013 22:17, Zhong Yu wrote: >> Stephen, would it be more accurate to say that what you want is >> actually non-"overridable". It's not a problem that B inherits foo() >> from A. It is a problem that B may introduce its own foo(), therefore >> the meaning of `B.foo()` is a little uncertain. > > No, its specifically that anyone reading B.foo() instead of A.foo() > would/could misunderstand what the code meant. > > I actually made the mistake myself, ie.with my own API. My call wasn't > type checked because it was being directly passed to an > assertEquals(Object,Object) in a test case. > > Stephen > From paul.sandoz at oracle.com Fri Jun 28 02:48:37 2013 From: paul.sandoz at oracle.com (paul.sandoz at oracle.com) Date: Fri, 28 Jun 2013 09:48:37 +0000 Subject: hg: lambda/lambda/jdk: Fully sync 166 F/J + executors with lambda. Message-ID: <20130628094933.80FD148635@hg.openjdk.java.net> Changeset: 92e541887022 Author: psandoz Date: 2013-06-28 11:48 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/92e541887022 Fully sync 166 F/J + executors with lambda. Sync concurrent tests in tl with lambda. ! src/share/classes/java/util/concurrent/AbstractExecutorService.java ! src/share/classes/java/util/concurrent/Callable.java ! src/share/classes/java/util/concurrent/CompletableFuture.java ! src/share/classes/java/util/concurrent/ExecutorService.java ! src/share/classes/java/util/concurrent/Executors.java ! src/share/classes/java/util/concurrent/FutureTask.java ! src/share/classes/java/util/concurrent/RecursiveAction.java ! src/share/classes/java/util/concurrent/RecursiveTask.java ! src/share/classes/java/util/concurrent/RunnableScheduledFuture.java ! src/share/classes/java/util/concurrent/ScheduledExecutorService.java ! src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java ! src/share/classes/java/util/concurrent/ThreadPoolExecutor.java ! test/java/util/concurrent/Executors/PrivilegedCallables.java ! test/java/util/concurrent/FutureTask/Throw.java ! test/java/util/concurrent/ThreadPoolExecutor/ThrowingTasks.java ! test/java/util/concurrent/locks/Lock/FlakyMutex.java From maurizio.cimadamore at oracle.com Fri Jun 28 03:56:27 2013 From: maurizio.cimadamore at oracle.com (maurizio.cimadamore at oracle.com) Date: Fri, 28 Jun 2013 10:56:27 +0000 Subject: hg: lambda/lambda/langtools: 8016175: Add bottom-up type-checking support for unambiguous method references Message-ID: <20130628105632.7291A48638@hg.openjdk.java.net> Changeset: eda4ff70411f Author: mcimadamore Date: 2013-06-28 11:54 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/eda4ff70411f 8016175: Add bottom-up type-checking support for unambiguous method references ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java ! src/share/classes/com/sun/tools/javac/comp/Infer.java ! src/share/classes/com/sun/tools/javac/comp/Resolve.java + test/tools/javac/lambda/MethodReference68.java + test/tools/javac/lambda/MethodReference68.out + test/tools/javac/lambda/MethodReference69.java + test/tools/javac/lambda/MethodReference69.out + test/tools/javac/lambda/MethodReference70.java + test/tools/javac/lambda/MethodReference70.out + test/tools/javac/lambda/MethodReference71.java + test/tools/javac/lambda/MethodReference71.out ! test/tools/javac/lambda/TargetType60.out From maurizio.cimadamore at oracle.com Fri Jun 28 07:56:05 2013 From: maurizio.cimadamore at oracle.com (maurizio.cimadamore at oracle.com) Date: Fri, 28 Jun 2013 14:56:05 +0000 Subject: hg: lambda/lambda/langtools: 86 new changesets Message-ID: <20130628150008.339AA48643@hg.openjdk.java.net> Changeset: 58eace4d997f Author: erikj Date: 2013-05-28 08:49 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/58eace4d997f 8012566: Replace find, rm, printf and similar with their proper variables Reviewed-by: tbell ! makefiles/BuildLangtools.gmk Changeset: 3597773628a4 Author: katleman Date: 2013-05-28 17:58 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/3597773628a4 Merge Changeset: 149890642a0e Author: katleman Date: 2013-05-29 10:16 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/149890642a0e 8015525: JDK8 b91 source with GPL header errors Reviewed-by: dholmes, lancea ! test/tools/javac/annotations/typeAnnotations/classfile/TestNewCastArray.java Changeset: 023e9a614d26 Author: katleman Date: 2013-05-30 10:58 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/023e9a614d26 Added tag jdk8-b92 for changeset 149890642a0e ! .hgtags Changeset: 0928f2cfbf8e Author: jjg Date: 2013-05-17 13:48 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/0928f2cfbf8e 6885876: add comments to javac/util/Convert.java Reviewed-by: mduigou ! src/share/classes/com/sun/tools/javac/util/Convert.java Changeset: 67cbd6d756f4 Author: jfranck Date: 2013-05-21 12:00 +0200 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/67cbd6d756f4 8013180: Qualified type reference with annotations in throws list crashes compiler Reviewed-by: jjg + test/tools/javac/annotations/typeAnnotations/8013180/QualifiedName.java Changeset: 824932ecdbc8 Author: vromero Date: 2013-05-21 11:41 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/824932ecdbc8 7177168: Redundant array copy in UnsharedNameTable Reviewed-by: mcimadamore ! src/share/classes/com/sun/tools/javac/util/UnsharedNameTable.java Changeset: 3d9750039fff Author: vromero Date: 2013-05-21 12:17 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/3d9750039fff 7060779: test/tools/javac/diags/Example.java leaves directories in tempdir Reviewed-by: mcimadamore ! test/tools/javac/diags/Example.java Changeset: 37295244f534 Author: vromero Date: 2013-05-21 13:50 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/37295244f534 8005207: test has 2 @bug tags Reviewed-by: mcimadamore ! test/tools/doclint/RunTest.java ! test/tools/javac/5045412/Bar.java ! test/tools/javac/5045412/Foo.java ! test/tools/javac/lambda/MethodReferenceParserTest.java ! test/tools/javac/lambda/TestInvokeDynamic.java ! test/tools/javac/mandatoryWarnings/deprecated/Test.java ! test/tools/javac/mandatoryWarnings/unchecked/Test.java ! test/tools/javac/policy/test3/Test.java Changeset: 08daea43a7f8 Author: vromero Date: 2013-05-21 14:33 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/08daea43a7f8 7164114: Two jtreg tests are not run due to no file extension on the test files Reviewed-by: mcimadamore - test/tools/javac/HiddenAbstractMethod/Test + test/tools/javac/HiddenAbstractMethod/Test.java - test/tools/javac/NonAmbiguousField/Test + test/tools/javac/NonAmbiguousField/Test.java ! test/tools/javac/NonAmbiguousField/two/Child2.java Changeset: 31344e8e3343 Author: lana Date: 2013-05-22 09:59 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/31344e8e3343 Merge Changeset: 3bd22f99d408 Author: darcy Date: 2013-05-22 13:34 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/3bd22f99d408 8010680: Clarify "present" and annotation ordering in javax.lang.model Reviewed-by: abuckley, jjg ! src/share/classes/javax/lang/model/AnnotatedConstruct.java ! src/share/classes/javax/lang/model/util/Elements.java Changeset: 58329d9f6b68 Author: mcimadamore Date: 2013-05-24 15:26 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/58329d9f6b68 8014643: Parser regression in JDK 8 when compiling super.x Summary: Fixed latent bug in JavacParser.analyzeParens() Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/parser/JavacParser.java + test/tools/javac/parser/8014643/T8014643.java Changeset: 97a9b4b3e63a Author: mcimadamore Date: 2013-05-24 15:27 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/97a9b4b3e63a 8014649: Regression: bug in Resolve.resolveOperator Summary: Missing curly braces causes Resolve.findMethod to be called spuriously Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/comp/Resolve.java ! test/tools/javac/resolve/ResolveHarness.java + test/tools/javac/resolve/tests/PrimitiveBinopOverload.java Changeset: 6e5076af4660 Author: mcimadamore Date: 2013-05-24 15:27 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/6e5076af4660 8014494: javac crashes when varargs element of a method reference is inferred from the context Summary: varargs element is not refreshed after type-inference Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/Check.java + test/tools/javac/lambda/TargetType73.java Changeset: 0f8e9a0e5d9a Author: darcy Date: 2013-05-24 11:26 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/0f8e9a0e5d9a 8014836: Have GenericDeclaration extend AnnotatedElement Reviewed-by: jfranck ! src/share/sample/language/model/CoreReflectionFactory.java Changeset: b391ecea538e Author: vromero Date: 2013-05-27 13:44 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/b391ecea538e 7030476: Fix conflicting use of JCTree/JCExpression Reviewed-by: mcimadamore ! src/share/classes/com/sun/tools/javac/comp/Lower.java ! src/share/classes/com/sun/tools/javac/tree/JCTree.java ! src/share/classes/com/sun/tools/javac/tree/TreeCopier.java ! src/share/classes/com/sun/tools/javac/tree/TreeMaker.java Changeset: c6df5b20f9eb Author: vromero Date: 2013-05-28 12:46 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/c6df5b20f9eb 6970173: Debug pointer at bad position Reviewed-by: mcimadamore ! src/share/classes/com/sun/tools/javac/comp/Lower.java + test/tools/javac/T6970173/DebugPointerAtBadPositionTest.java Changeset: d042cba65eab Author: vromero Date: 2013-05-28 17:39 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/d042cba65eab 8012333: javac, ClassFile should have a read(Path) method Reviewed-by: jjg ! src/share/classes/com/sun/tools/classfile/ClassFile.java Changeset: 92e420e9807d Author: vromero Date: 2013-05-29 10:56 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/92e420e9807d 7053059: VerifyError with double Assignment using a Generic Member of a Superclass Reviewed-by: mcimadamore ! src/share/classes/com/sun/tools/javac/comp/TransTypes.java + test/tools/javac/T7053059/VerifyErrorWithDoubleAssignmentTest.java Changeset: d685b12b62a4 Author: jjg Date: 2013-05-29 15:34 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/d685b12b62a4 8015641: genstubs needs to cope with static interface methods Reviewed-by: ksrini ! make/tools/genstubs/GenStubs.java Changeset: 18943a1b7a47 Author: lana Date: 2013-05-29 16:59 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/18943a1b7a47 Merge - test/tools/javac/HiddenAbstractMethod/Test - test/tools/javac/NonAmbiguousField/Test Changeset: 2c5a568ee36e Author: lana Date: 2013-06-03 23:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/2c5a568ee36e Merge - test/tools/javac/HiddenAbstractMethod/Test - test/tools/javac/NonAmbiguousField/Test Changeset: 888386fddc09 Author: katleman Date: 2013-06-06 09:55 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/888386fddc09 Added tag jdk8-b93 for changeset 2c5a568ee36e ! .hgtags Changeset: 9f11c7676cd5 Author: vromero Date: 2013-05-31 10:04 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/9f11c7676cd5 7179353: try-with-resources fails to compile with generic exception parameters Reviewed-by: mcimadamore ! src/share/classes/com/sun/tools/javac/comp/Flow.java ! src/share/classes/com/sun/tools/javac/comp/Resolve.java + test/tools/javac/T7179353/GenericsAndTWRCompileErrorTest.java Changeset: e9855150c5b0 Author: vromero Date: 2013-06-01 21:57 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/e9855150c5b0 8010737: javac, known parameter's names should be copied to automatically generated constructors for inner classes Reviewed-by: mcimadamore ! src/share/classes/com/sun/tools/javac/comp/MemberEnter.java ! test/tools/javac/MethodParameters/ClassFileVisitor.java ! test/tools/javac/MethodParameters/ReflectionVisitor.java + test/tools/javac/T8010737/ParameterNamesAreNotCopiedToAnonymousInitTest.java Changeset: ec871c3e8337 Author: vromero Date: 2013-06-01 22:09 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/ec871c3e8337 6695379: Copy method annotations and parameter annotations to synthetic bridge methods Reviewed-by: mcimadamore ! src/share/classes/com/sun/tools/javac/comp/TransTypes.java ! src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java ! test/tools/javac/6889255/T6889255.java ! test/tools/javac/MethodParameters/ClassFileVisitor.java ! test/tools/javac/MethodParameters/ReflectionVisitor.java ! test/tools/javac/MethodParameters/Tester.java + test/tools/javac/T6695379/AnnotationsAreNotCopiedToBridgeMethodsTest.java Changeset: 391f97e270c2 Author: jjg Date: 2013-06-03 16:22 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/391f97e270c2 8013405: DocLint should support
  • Reviewed-by: ksrini ! src/share/classes/com/sun/tools/doclint/Checker.java ! src/share/classes/com/sun/tools/doclint/HtmlTag.java ! src/share/classes/com/sun/tools/doclint/resources/doclint.properties ! test/tools/doclint/html/ListTagsTest.java + test/tools/doclint/html/ListTagsTest.out Changeset: 8258f84a8649 Author: lana Date: 2013-06-03 16:10 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/8258f84a8649 Merge Changeset: 7a4fd1076b15 Author: lana Date: 2013-06-03 16:56 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/7a4fd1076b15 Merge Changeset: 242bcad5be74 Author: jjg Date: 2013-06-03 17:09 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/242bcad5be74 8006615: [doclint] move remaining messages into resource bundle Reviewed-by: mcimadamore, vromero ! src/share/classes/com/sun/tools/doclint/DocLint.java ! src/share/classes/com/sun/tools/doclint/resources/doclint.properties + test/tools/doclint/ResourceTest.java ! test/tools/doclint/tool/RunTest.java Changeset: 019063968164 Author: jjg Date: 2013-06-03 17:24 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/019063968164 8007687: javadoc -X does not include -Xdoclint Reviewed-by: darcy ! src/share/classes/com/sun/tools/doclets/formats/html/ConfigurationImpl.java ! src/share/classes/com/sun/tools/doclets/formats/html/resources/standard.properties ! src/share/classes/com/sun/tools/javac/resources/javac.properties ! src/share/classes/com/sun/tools/javadoc/Start.java ! src/share/classes/com/sun/tools/javadoc/resources/javadoc.properties ! test/com/sun/javadoc/testHelpOption/TestHelpOption.java + test/com/sun/javadoc/testXOption/TestXOption.java Changeset: 5cd3cb69c8b3 Author: mcimadamore Date: 2013-06-04 11:30 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/5cd3cb69c8b3 7116676: RichDiagnosticFormatter throws NPE when formatMessage is called directly Summary: Fix NPE in RichDiagnosticFormatter.formatMessage Reviewed-by: jjg ! src/share/classes/com/sun/tools/javac/util/RichDiagnosticFormatter.java + test/tools/javac/Diagnostics/7116676/T7116676.java Changeset: 32c50b5f70b5 Author: mcimadamore Date: 2013-06-04 11:31 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/32c50b5f70b5 8008160: Five lambda TargetType tests have @ignore Summary: Remove @ignore flags from tests that now pass Reviewed-by: jjg ! test/tools/javac/lambda/TargetType53.java ! test/tools/javac/lambda/TargetType54.java ! test/tools/javac/lambda/TargetType58.java ! test/tools/javac/lambda/TargetType59.java ! test/tools/javac/lambda/TargetType62.java Changeset: c8acc254b6d7 Author: mcimadamore Date: 2013-06-04 11:34 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/c8acc254b6d7 8015505: Spurious inference error when return type of generic method requires unchecked conversion to target Summary: Use check context compatibility during 15.12.2.8 check (only when JDK 8 inference is enabled) Reviewed-by: jjg ! src/share/classes/com/sun/tools/javac/comp/Infer.java + test/tools/javac/generics/inference/8015505/T8015505.java + test/tools/javac/generics/inference/8015505/T8015505.out ! test/tools/javac/generics/rawOverride/7062745/GenericOverrideTest.java Changeset: 775a51e3276f Author: vromero Date: 2013-06-04 13:21 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/775a51e3276f 7165659: javac incorrectly sets strictfp access flag on inner-classes Reviewed-by: jjg, mcimadamore ! src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java + test/tools/javac/T7165659/InnerClassAttrMustNotHaveStrictFPFlagTest.java Changeset: 8fb68f73d4b1 Author: jjg Date: 2013-06-04 14:17 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/8fb68f73d4b1 8004643: Reduce javac space overhead introduced with compiler support for repeating annotations Reviewed-by: mcimadamore, jfranck ! src/share/classes/com/sun/tools/javac/code/Lint.java ! src/share/classes/com/sun/tools/javac/code/Symbol.java ! src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/Enter.java ! src/share/classes/com/sun/tools/javac/comp/Flow.java ! src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java ! src/share/classes/com/sun/tools/javac/comp/Lower.java ! src/share/classes/com/sun/tools/javac/comp/MemberEnter.java ! src/share/classes/com/sun/tools/javac/comp/TransTypes.java ! src/share/classes/com/sun/tools/javac/jvm/ClassReader.java ! src/share/classes/com/sun/tools/javac/jvm/Code.java ! src/share/classes/com/sun/tools/javac/jvm/Gen.java ! src/share/classes/com/sun/tools/javac/jvm/JNIWriter.java ! src/share/classes/com/sun/tools/javac/sym/CreateSymbols.java ! src/share/classes/com/sun/tools/javac/tree/TreeInfo.java ! test/tools/javac/lib/DPrinter.java Changeset: 9acd0f8d6e44 Author: lana Date: 2013-06-04 21:38 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/9acd0f8d6e44 Merge Changeset: 79fd9cfa55f2 Author: kizune Date: 2013-06-05 16:58 +0400 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/79fd9cfa55f2 7186887: Test T6567415.java can fail on a slow machine Reviewed-by: jjg, ksrini ! test/tools/javac/6567415/T6567415.java Changeset: 48c6e6ab7c81 Author: lana Date: 2013-06-10 17:04 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/48c6e6ab7c81 Merge Changeset: 4cb113623127 Author: katleman Date: 2013-06-13 09:49 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/4cb113623127 Added tag jdk8-b94 for changeset 48c6e6ab7c81 ! .hgtags Changeset: 3478b1e81baf Author: katleman Date: 2013-06-20 10:17 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/3478b1e81baf Added tag jdk8-b95 for changeset 4cb113623127 ! .hgtags Changeset: 8717586f7b05 Author: emc Date: 2013-06-06 08:48 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/8717586f7b05 8015701: MethodParameters are not filled in for synthetic captured local variables Summary: Synthetic parameters for captured local variables in an anonymous inner class are not added to MethodParameters attributes Reviewed-by: mcimadamore ! src/share/classes/com/sun/tools/javac/comp/Lower.java + test/tools/javac/8015701/AnonymousParameters.java Changeset: 6e30a513c945 Author: mcimadamore Date: 2013-06-06 15:30 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/6e30a513c945 6360970: javac erroneously accept ambiguous field reference Summary: clash between ambiguous fields in superinterface and unambiguous field in subinterface is erroneously marked as unambiguous Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/comp/Resolve.java + test/tools/javac/6360970/T6360970.java + test/tools/javac/6360970/T6360970.out Changeset: 7889d1fe2597 Author: mcimadamore Date: 2013-06-06 15:32 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/7889d1fe2597 7139681: Enhanced for loop: local variable scope inconsistent with JLS Summary: For-each loop variable is incorrectly visible from the for-each expression Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/comp/Attr.java + test/tools/javac/foreach/7139681/T7139681neg.java + test/tools/javac/foreach/7139681/T7139681neg.out + test/tools/javac/foreach/7139681/T7139681pos.java Changeset: 349160289ba2 Author: mcimadamore Date: 2013-06-06 15:33 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/349160289ba2 8008627: Compiler mishandles three-way return-type-substitutability Summary: Compiler should not enforce an order in how ambiguous methods should be resolved Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/comp/Check.java + test/tools/javac/generics/rawOverride/T8008627.java ! test/tools/javac/lambda/funcInterfaces/NonSAM2.java ! test/tools/javac/lambda/funcInterfaces/NonSAM2.out Changeset: f8472e561a97 Author: mcimadamore Date: 2013-06-06 15:35 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/f8472e561a97 8015432: javac crashes with stack overflow when method called recursively from nested generic call Summary: Check.checkMethod should only be called after inference has completed Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/Check.java ! test/tools/javac/6758789/T6758789b.out ! test/tools/javac/generics/7015430/T7015430.out ! test/tools/javac/generics/7151802/T7151802.out ! test/tools/javac/generics/inference/6718364/T6718364.out ! test/tools/javac/generics/inference/7177306/T7177306a.out + test/tools/javac/lambda/TargetType74.java Changeset: f218bb5ebd53 Author: mcimadamore Date: 2013-06-06 15:37 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/f218bb5ebd53 8015648: Duplicate variable in lambda causes javac crash Summary: Missing flag in synthetic lambda blog is causing duplicates symbol to go undetected Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/comp/Attr.java + test/tools/javac/lambda/LambdaScope05.java + test/tools/javac/lambda/LambdaScope05.out Changeset: 5b039297151e Author: mcimadamore Date: 2013-06-06 15:38 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/5b039297151e Merge Changeset: fd31bf97340f Author: jjg Date: 2013-06-07 15:35 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/fd31bf97340f 8016193: Fix OAC issue in langtools docs Reviewed-by: darcy ! src/share/classes/com/sun/javadoc/Tag.java Changeset: 105d1f9c1ab8 Author: vromero Date: 2013-06-10 15:18 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/105d1f9c1ab8 7113519: test/tools/javac/VersionOpt.java passes on windows Reviewed-by: jjg ! test/tools/javac/VersionOpt.java Changeset: 3582b62dccb2 Author: mcimadamore Date: 2013-06-10 15:57 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/3582b62dccb2 8013576: Add stat support to LambdaToMethod Summary: LambdaToMethod should emit info to help diagnose/test lambda metafactory problems Reviewed-by: jjg, vromero ! src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java ! src/share/classes/com/sun/tools/javac/resources/compiler.properties + test/tools/javac/diags/examples/LambdaStat.java + test/tools/javac/diags/examples/MrefStat.java + test/tools/javac/diags/examples/MrefStat.java.rej + test/tools/javac/diags/examples/MrefStat1.java + test/tools/javac/diags/examples/MrefStat1.java.rej + test/tools/javac/lambda/TestLambdaToMethodStats.java Changeset: bbedff0dc37e Author: vromero Date: 2013-06-11 09:35 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/bbedff0dc37e 8008547: javac, warning message: use of ''_'' as an identifier might not be supported in future releases, should be more especific Reviewed-by: jjg ! src/share/classes/com/sun/tools/javac/resources/compiler.properties Changeset: 7fe655cad9b1 Author: vromero Date: 2013-06-11 09:59 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/7fe655cad9b1 8007907: javap, method com.sun.tools.javap.Main.run returns 0 even in case of class not found error Reviewed-by: jjg ! src/share/classes/com/sun/tools/javap/JavapTask.java ! test/tools/javac/constDebug/ConstDebugTest.java ! test/tools/javap/8006334/JavapTaskCtorFailWithNPE.java + test/tools/javap/8007907/JavapReturns0AfterClassNotFoundTest.java ! test/tools/javap/T4777949.java ! test/tools/javap/T7190862.java Changeset: 6b48ebae2569 Author: vromero Date: 2013-06-14 16:25 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/6b48ebae2569 8016569: javac, add new flag for polymorphic method signatures Reviewed-by: jjg Contributed-by: maurizio.cimadamore at oracle.com ! src/share/classes/com/sun/tools/javac/code/Flags.java ! src/share/classes/com/sun/tools/javac/code/Symbol.java ! src/share/classes/com/sun/tools/javac/code/Types.java ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/Check.java ! src/share/classes/com/sun/tools/javac/comp/MemberEnter.java ! src/share/classes/com/sun/tools/javac/comp/Resolve.java ! src/share/classes/com/sun/tools/javac/jvm/ClassReader.java Changeset: 1936a884b290 Author: vromero Date: 2013-06-14 18:01 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/1936a884b290 8008023: Get rid of utf8 chars in two tests Reviewed-by: jjg ! test/tools/javac/api/6437999/Utf8.java ! test/tools/javac/api/T6306137.java Changeset: 1eb09dba594a Author: lana Date: 2013-06-16 22:38 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/1eb09dba594a Merge Changeset: b7a10bc02e7a Author: darcy Date: 2013-06-17 14:46 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/b7a10bc02e7a 8016779: Fix doclint warnings in javax.lang.model Reviewed-by: jjg ! src/share/classes/javax/lang/model/util/ElementScanner6.java ! src/share/classes/javax/lang/model/util/ElementScanner7.java ! src/share/classes/javax/lang/model/util/ElementScanner8.java ! src/share/classes/javax/lang/model/util/SimpleTypeVisitor6.java Changeset: 455be95bd1b5 Author: rfield Date: 2013-06-17 20:29 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/455be95bd1b5 8013789: Compiler should emit bridges in interfaces Summary: paired with 8015402: Lambda metafactory should not attempt to determine bridge methods Reviewed-by: vromero Contributed-by: maurizio.cimadamore at oracle.com ! src/share/classes/com/sun/tools/javac/code/Types.java ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/Check.java ! src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java ! src/share/classes/com/sun/tools/javac/comp/TransTypes.java ! src/share/classes/com/sun/tools/javac/tree/JCTree.java ! test/tools/javac/lambda/lambdaExpression/LambdaTest6.java ! test/tools/javac/lambda/methodReference/BridgeMethod.java Changeset: e701af23a095 Author: vromero Date: 2013-06-18 18:57 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/e701af23a095 8016607: javac, avoid analyzing lambdas for source 7 compilation Reviewed-by: jjg Contributed-by: maurizio.cimadamore at oracle.com ! src/share/classes/com/sun/tools/javac/main/JavaCompiler.java Changeset: 9851071b551a Author: vromero Date: 2013-06-18 19:02 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/9851071b551a 8016267: javac, TypeTag refactoring has provoked performance issues Reviewed-by: jjg ! src/share/classes/com/sun/tools/javac/code/Type.java ! src/share/classes/com/sun/tools/javac/code/TypeTag.java ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/Check.java ! src/share/classes/com/sun/tools/javac/comp/Infer.java Changeset: 4d4818b6df72 Author: chegar Date: 2013-04-24 11:03 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/4d4818b6df72 Merge Changeset: 27cda5134748 Author: chegar Date: 2013-04-28 08:16 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/27cda5134748 Merge Changeset: c7c6bfe7fc1f Author: bpatel Date: 2013-05-03 08:52 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/c7c6bfe7fc1f 8012375: Improve Javadoc framing Reviewed-by: mduigou, jlaskey ! src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlWriter.java ! test/com/sun/javadoc/testJavascript/TestJavascript.java Changeset: 8074ccd57d89 Author: chegar Date: 2013-05-08 10:27 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/8074ccd57d89 Merge Changeset: 9d7d36e6927c Author: chegar Date: 2013-05-08 10:28 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/9d7d36e6927c Merge Changeset: 7ee1fd365cdd Author: chegar Date: 2013-05-16 11:42 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/7ee1fd365cdd Merge Changeset: f1b90ea7d402 Author: chegar Date: 2013-05-23 12:50 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/f1b90ea7d402 Merge - src/share/classes/com/sun/tools/doclets/formats/html/TagletOutputImpl.java ! src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlWriter.java - src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/ExpertTaglet.java - src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletOutput.java - src/share/classes/javax/tools/annotation/GenerateNativeHeader.java - test/tools/javac/nativeHeaders/javahComparison/TestClass2.java - test/tools/javac/nativeHeaders/javahComparison/TestClass3.java Changeset: 76d08c649607 Author: chegar Date: 2013-05-31 10:28 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/76d08c649607 Merge Changeset: 536cad596942 Author: bpatel Date: 2013-06-07 16:12 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/536cad596942 8015997: Additional improvement in Javadoc framing Reviewed-by: jjg ! src/share/classes/com/sun/tools/doclets/formats/html/markup/HtmlWriter.java ! test/com/sun/javadoc/testJavascript/TestJavascript.java Changeset: da8d0ee0938e Author: chegar Date: 2013-06-10 09:52 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/da8d0ee0938e Merge - test/tools/javac/HiddenAbstractMethod/Test - test/tools/javac/NonAmbiguousField/Test Changeset: cc89c8333127 Author: chegar Date: 2013-06-11 09:25 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/cc89c8333127 Merge Changeset: 31e1151ef3cc Author: chegar Date: 2013-06-17 11:27 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/31e1151ef3cc Merge Changeset: db6bf740a578 Author: chegar Date: 2013-06-18 09:36 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/db6bf740a578 Merge Changeset: 64f511787fd9 Author: chegar Date: 2013-06-18 20:08 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/64f511787fd9 Merge Changeset: 792c40d5185a Author: mfang Date: 2013-06-18 20:56 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/792c40d5185a 8015657: jdk8 l10n resource file translation update 3 Reviewed-by: yhuang ! src/share/classes/com/sun/tools/doclets/formats/html/resources/standard_ja.properties ! src/share/classes/com/sun/tools/doclets/formats/html/resources/standard_zh_CN.properties ! src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/doclets_ja.properties ! src/share/classes/com/sun/tools/doclets/internal/toolkit/resources/doclets_zh_CN.properties + src/share/classes/com/sun/tools/doclint/resources/doclint_ja.properties + src/share/classes/com/sun/tools/doclint/resources/doclint_zh_CN.properties ! src/share/classes/com/sun/tools/javac/resources/compiler_ja.properties ! src/share/classes/com/sun/tools/javac/resources/compiler_zh_CN.properties ! src/share/classes/com/sun/tools/javac/resources/javac_ja.properties ! src/share/classes/com/sun/tools/javac/resources/javac_zh_CN.properties ! src/share/classes/com/sun/tools/javadoc/resources/javadoc_ja.properties + src/share/classes/com/sun/tools/javap/resources/javap_ja.properties + src/share/classes/com/sun/tools/javap/resources/javap_zh_CN.properties + src/share/classes/com/sun/tools/jdeps/resources/jdeps_ja.properties + src/share/classes/com/sun/tools/jdeps/resources/jdeps_zh_CN.properties Changeset: 6d3b33aea370 Author: vromero Date: 2013-06-19 11:09 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/6d3b33aea370 8006981: javac, method toString() of class ...javac.code.Flags doesn't print all the flag bits Reviewed-by: jjg ! src/share/classes/com/sun/tools/javac/code/Flags.java ! src/share/classes/com/sun/tools/javac/comp/Check.java Changeset: be62183f938a Author: chegar Date: 2013-06-19 11:48 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/be62183f938a 8017045: anti-delta fix for 8013789 Reviewed-by: alanb ! src/share/classes/com/sun/tools/javac/code/Types.java ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/Check.java ! src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java ! src/share/classes/com/sun/tools/javac/comp/TransTypes.java ! src/share/classes/com/sun/tools/javac/tree/JCTree.java ! test/tools/javac/lambda/lambdaExpression/LambdaTest6.java ! test/tools/javac/lambda/methodReference/BridgeMethod.java Changeset: 29dcd6715b04 Author: chegar Date: 2013-06-19 13:00 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/29dcd6715b04 Merge ! src/share/classes/com/sun/tools/javac/comp/Check.java Changeset: be10ac0081b2 Author: vromero Date: 2013-06-19 22:07 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/be10ac0081b2 8016610: javac, add new internal symbols to make operator resolution faster Reviewed-by: jjg Contributed-by: maurizio.cimadamore at oracle.com ! src/share/classes/com/sun/tools/javac/code/Symtab.java ! src/share/classes/com/sun/tools/javac/tree/TreeInfo.java Changeset: b3458329d060 Author: lana Date: 2013-06-24 14:27 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/b3458329d060 Merge Changeset: 988aef3a8c3a Author: katleman Date: 2013-06-26 11:26 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/988aef3a8c3a 8016684: JDK8 b94 source with GPL header errors Reviewed-by: tbell, darcy ! test/tools/javac/6567415/T6567415.java Changeset: 6a11a81a8824 Author: katleman Date: 2013-06-27 13:40 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/6a11a81a8824 Added tag jdk8-b96 for changeset 988aef3a8c3a ! .hgtags Changeset: 5b5de35cfb10 Author: mcimadamore Date: 2013-06-28 14:37 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/5b5de35cfb10 merge with jdk8-b96 ! .hgtags ! src/share/classes/com/sun/tools/doclets/formats/html/resources/standard.properties ! src/share/classes/com/sun/tools/javac/code/Flags.java ! src/share/classes/com/sun/tools/javac/code/Lint.java ! src/share/classes/com/sun/tools/javac/code/Symbol.java ! src/share/classes/com/sun/tools/javac/code/Symtab.java ! src/share/classes/com/sun/tools/javac/code/Type.java ! src/share/classes/com/sun/tools/javac/code/TypeTag.java ! src/share/classes/com/sun/tools/javac/code/Types.java ! src/share/classes/com/sun/tools/javac/comp/Attr.java ! src/share/classes/com/sun/tools/javac/comp/Check.java ! src/share/classes/com/sun/tools/javac/comp/Enter.java ! src/share/classes/com/sun/tools/javac/comp/Flow.java ! src/share/classes/com/sun/tools/javac/comp/Infer.java ! src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java ! src/share/classes/com/sun/tools/javac/comp/Lower.java ! src/share/classes/com/sun/tools/javac/comp/MemberEnter.java ! src/share/classes/com/sun/tools/javac/comp/Resolve.java ! src/share/classes/com/sun/tools/javac/comp/TransTypes.java ! src/share/classes/com/sun/tools/javac/jvm/ClassReader.java ! src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java ! src/share/classes/com/sun/tools/javac/jvm/Code.java ! src/share/classes/com/sun/tools/javac/jvm/Gen.java ! src/share/classes/com/sun/tools/javac/main/JavaCompiler.java ! src/share/classes/com/sun/tools/javac/parser/JavacParser.java ! src/share/classes/com/sun/tools/javac/resources/compiler.properties ! src/share/classes/com/sun/tools/javac/resources/javac.properties ! src/share/classes/com/sun/tools/javac/sym/CreateSymbols.java ! src/share/classes/com/sun/tools/javac/tree/JCTree.java ! src/share/classes/com/sun/tools/javac/tree/TreeCopier.java ! src/share/classes/com/sun/tools/javac/tree/TreeInfo.java ! src/share/classes/com/sun/tools/javac/tree/TreeMaker.java ! src/share/classes/com/sun/tools/javac/util/RichDiagnosticFormatter.java ! src/share/classes/com/sun/tools/javap/JavapTask.java ! test/tools/javac/6758789/T6758789b.out ! test/tools/javac/6889255/T6889255.java - test/tools/javac/HiddenAbstractMethod/Test - test/tools/javac/NonAmbiguousField/Test ! test/tools/javac/generics/7015430/T7015430_1.out ! test/tools/javac/generics/7015430/T7015430_2.out ! test/tools/javac/generics/rawOverride/7062745/GenericOverrideTest.java ! test/tools/javac/lambda/MethodReferenceParserTest.java ! test/tools/javac/lambda/TargetType53.java ! test/tools/javac/lambda/TargetType54.java ! test/tools/javac/lambda/TargetType58.java ! test/tools/javac/lambda/TargetType59.java ! test/tools/javac/lambda/TargetType62.java ! test/tools/javac/lambda/TargetType73.java ! test/tools/javac/lambda/TargetType74.java ! test/tools/javac/lambda/TestInvokeDynamic.java ! test/tools/javac/lambda/TestLambdaToMethodStats.java ! test/tools/javac/lambda/lambdaExpression/LambdaTest6.java ! test/tools/javac/lambda/methodReference/BridgeMethod.java ! test/tools/javac/resolve/ResolveHarness.java Changeset: dca9dd25841f Author: mcimadamore Date: 2013-06-28 15:08 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/dca9dd25841f Fix spurious test failures ! test/tools/javac/6889255/T6889255.java ! test/tools/javac/api/6437999/T6437999.java ! test/tools/javac/api/T6306137.java ! test/tools/javac/diags/examples.not-yet.txt ! test/tools/javac/lambda/TargetType59.java ! test/tools/javac/lambda/TargetType62.java Changeset: dbb6ac0ec636 Author: mcimadamore Date: 2013-06-28 15:13 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/dbb6ac0ec636 Remove spurious files - test/tools/javac/diags/examples/MrefStat.java.rej - test/tools/javac/diags/examples/MrefStat1.java.rej From brian.goetz at oracle.com Fri Jun 28 08:18:28 2013 From: brian.goetz at oracle.com (brian.goetz at oracle.com) Date: Fri, 28 Jun 2013 15:18:28 +0000 Subject: hg: lambda/lambda/jdk: Fix bug in spliterator test Message-ID: <20130628151856.A3D0748646@hg.openjdk.java.net> Changeset: cda1f806d3d9 Author: briangoetz Date: 2013-06-28 11:13 -0400 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/cda1f806d3d9 Fix bug in spliterator test ! test/java/util/Spliterator/SpliteratorCollisions.java From ali.ebrahimi1781 at gmail.com Fri Jun 28 09:59:04 2013 From: ali.ebrahimi1781 at gmail.com (Ali Ebrahimi) Date: Fri, 28 Jun 2013 21:29:04 +0430 Subject: hg: lambda/lambda/langtools: 8016175: Add bottom-up type-checking support for unambiguous method references In-Reply-To: <20130628105632.7291A48638@hg.openjdk.java.net> References: <20130628105632.7291A48638@hg.openjdk.java.net> Message-ID: Hi Maurizio, In test MethodReference71 I don't get why g(this::m2) is ambiguous. please clarify this for me. thanks in advance. +class MethodReference71 { + interface F { + void m(X x); + } + + interface G { + Integer m(X x); + } + + void m1(Integer i) { } + void m2(Integer... i) { } + + void g(F f) { } + void g(G g) { } + + void test() { + g(this::m1); //ok + g(this::m2); //ambiguous (stuck!) + } +} Ali Ebrahimi On Fri, Jun 28, 2013 at 3:26 PM, wrote: > Changeset: eda4ff70411f > Author: mcimadamore > Date: 2013-06-28 11:54 +0100 > URL: > http://hg.openjdk.java.net/lambda/lambda/langtools/rev/eda4ff70411f > > 8016175: Add bottom-up type-checking support for unambiguous method > references > > ! src/share/classes/com/sun/tools/javac/comp/Attr.java > ! src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java > ! src/share/classes/com/sun/tools/javac/comp/Infer.java > ! src/share/classes/com/sun/tools/javac/comp/Resolve.java > + test/tools/javac/lambda/MethodReference68.java > + test/tools/javac/lambda/MethodReference68.out > + test/tools/javac/lambda/MethodReference69.java > + test/tools/javac/lambda/MethodReference69.out > + test/tools/javac/lambda/MethodReference70.java > + test/tools/javac/lambda/MethodReference70.out > + test/tools/javac/lambda/MethodReference71.java > + test/tools/javac/lambda/MethodReference71.out > ! test/tools/javac/lambda/TargetType60.out > > > From maurizio.cimadamore at oracle.com Fri Jun 28 09:39:11 2013 From: maurizio.cimadamore at oracle.com (maurizio.cimadamore at oracle.com) Date: Fri, 28 Jun 2013 16:39:11 +0000 Subject: hg: lambda/lambda/langtools: 8017618: NullPointerException in RichDiagnosticFormatter for bad input program Message-ID: <20130628163918.19D874864E@hg.openjdk.java.net> Changeset: b6fec45b61e3 Author: mcimadamore Date: 2013-06-28 17:38 +0100 URL: http://hg.openjdk.java.net/lambda/lambda/langtools/rev/b6fec45b61e3 8017618: NullPointerException in RichDiagnosticFormatter for bad input program ! src/share/classes/com/sun/tools/javac/util/RichDiagnosticFormatter.java From nicholas+openjdk at nicholaswilliams.net Fri Jun 28 10:27:22 2013 From: nicholas+openjdk at nicholaswilliams.net (Nick Williams) Date: Fri, 28 Jun 2013 12:27:22 -0500 Subject: Invalid method reference with generics In-Reply-To: <51CBEB51.10302@oracle.com> References: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> <51CB17F0.9040503@oracle.com> <73611695-63E8-4923-85C3-FDEDF47AFEB1@nicholaswilliams.net> <51CB2476.4040800@oracle.com> <51CBEB51.10302@oracle.com> Message-ID: <3113120E-ED84-4F35-98D3-850F9C2C2437@nicholaswilliams.net> On Jun 27, 2013, at 2:35 AM, Maurizio Cimadamore wrote: > On 26/06/13 18:43, Nick Williams wrote: >> However, I CAN do this (it compiles and runs just fine): >> >> register(new ApplicationListener() { >> public void onApplicationEvent(Event1 event) { } >> }); >> >> So, by extension, I SHOULD be able to do this, but can't: >> >> void onApplicationEvent(Event1 event) { } >> register(this::onApplicationEvent); >> >> We have inconsistent behavior here. In your example, both the method reference and the anonymous inner class are illegal. In my use case, the compiler allows the anonymous inner class but prohibits the method reference. That inconsistency is a real problem. There is_no_ semantic difference between what I'm doing with the anonymous inner class and what I'm doing with the method reference. Zero. The method signatures are identical (I event named them the same here to drive home the point), but one works and the other doesn't. >> >> Nick >> > Yes and no - the inner class you are creating is a subtype of: > > ApplicationListener > > while the type inferred by the compler as a target is: > > ApplicationListener (wildcard removed as per spec) > > This is why you get the 'weird' behavior. To express what you mean, you need to do the following: > > public static void register(ApplicationListener listener) { } > > The compiler will infer Z == Event1 and all will be fine. Well, it will fail with an inference error for now, but we have plans to fix that in the future. > > Maurizio So, just so that I know I understand you correctly, you're saying that if I want to do it like this (which is something I tried previously and it did not work): public static void register(ApplicationListener listener) { } public void onEvent1(Event1 event1) { } public void initialize() { register(this::onEvent1); } I SHOULD be able to do this and I WILL be able to do this at some point before Java 8 is complete, but right now it's just not working. Do I understand that correctly? Nick From henry.jen at oracle.com Fri Jun 28 17:34:44 2013 From: henry.jen at oracle.com (henry.jen at oracle.com) Date: Sat, 29 Jun 2013 00:34:44 +0000 Subject: hg: lambda/lambda/jdk: tests for xxxStream.concat Message-ID: <20130629003509.6C9144866A@hg.openjdk.java.net> Changeset: 1a72d7c8cc96 Author: henryjen Date: 2013-06-28 17:33 -0700 URL: http://hg.openjdk.java.net/lambda/lambda/jdk/rev/1a72d7c8cc96 tests for xxxStream.concat ! test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatOpTest.java From henry.jen at oracle.com Fri Jun 28 17:58:42 2013 From: henry.jen at oracle.com (Henry Jen) Date: Fri, 28 Jun 2013 17:58:42 -0700 Subject: RFR: 8015315: Stream.concat methods Message-ID: <51CE3142.60800@oracle.com> Hi, Please review the webrev that add concat static method to Stream and primitive Streams. http://cr.openjdk.java.net/~henryjen/ccc/8015315.0/webrev/ Cheers, Henry From maurizio.cimadamore at oracle.com Sat Jun 29 04:54:41 2013 From: maurizio.cimadamore at oracle.com (maurizio cimadamore) Date: Sat, 29 Jun 2013 12:54:41 +0100 Subject: hg: lambda/lambda/langtools: 8016175: Add bottom-up type-checking support for unambiguous method references In-Reply-To: References: <20130628105632.7291A48638@hg.openjdk.java.net> Message-ID: <51CECB01.3020503@oracle.com> On 28-Jun-13 5:59 PM, Ali Ebrahimi wrote: > Hi Maurizio, > In test MethodReference71 I don't get why g(this::m2) is ambiguous. > please clarify this for me. thanks in advance. It's not ambiguous, sorry for the typo in the test; however it's erroneous, as the compiler doesn't have enough information to type-check the method reference. If, however, the method reference is unambiguous _and_ not a varargs (as the first case), the compiler will go bottom up and 'unstick' the method reference. We decided against the varargs case as, in the general case, that would require support for disjunctive type inference, and we wanted to limit the scope of the change at this point of the release. Thanks Maurizio > +class MethodReference71 { > + interface F { > + void m(X x); > + } > + > + interface G { > + Integer m(X x); > + } > + > + void m1(Integer i) { } > + void m2(Integer... i) { } > + > + void g(F f) { } > + void g(G g) { } > + > + void test() { > + g(this::m1); //ok > + g(this::m2); //ambiguous (stuck!) > + } > +} > Ali Ebrahimi > > > On Fri, Jun 28, 2013 at 3:26 PM, > wrote: > > Changeset: eda4ff70411f > Author: mcimadamore > Date: 2013-06-28 11:54 +0100 > URL: > http://hg.openjdk.java.net/lambda/lambda/langtools/rev/eda4ff70411f > > 8016175: Add bottom-up type-checking support for unambiguous > method references > > ! src/share/classes/com/sun/tools/javac/comp/Attr.java > ! src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java > ! src/share/classes/com/sun/tools/javac/comp/Infer.java > ! src/share/classes/com/sun/tools/javac/comp/Resolve.java > + test/tools/javac/lambda/MethodReference68.java > + test/tools/javac/lambda/MethodReference68.out > + test/tools/javac/lambda/MethodReference69.java > + test/tools/javac/lambda/MethodReference69.out > + test/tools/javac/lambda/MethodReference70.java > + test/tools/javac/lambda/MethodReference70.out > + test/tools/javac/lambda/MethodReference71.java > + test/tools/javac/lambda/MethodReference71.out > ! test/tools/javac/lambda/TargetType60.out > > > From maurizio.cimadamore at oracle.com Sat Jun 29 05:00:22 2013 From: maurizio.cimadamore at oracle.com (Maurizio Cimadamore) Date: Sat, 29 Jun 2013 13:00:22 +0100 Subject: Invalid method reference with generics In-Reply-To: <3113120E-ED84-4F35-98D3-850F9C2C2437@nicholaswilliams.net> References: <6836058D-C3F1-4797-86D2-1202EB4E195C@nicholaswilliams.net> <51CB17F0.9040503@oracle.com> <73611695-63E8-4923-85C3-FDEDF47AFEB1@nicholaswilliams.net> <51CB2476.4040800@oracle.com> <51CBEB51.10302@oracle.com> <3113120E-ED84-4F35-98D3-850F9C2C2437@nicholaswilliams.net> Message-ID: <51CECC56.8050303@oracle.com> This code: interface ApplicationListener { void onApplicationEvent(E e); } class ApplicationEvent { } class Event1 extends ApplicationEvent { } class Test { public static void register(ApplicationListener listener) { } public void onEvent1(Event1 event1) { } public void initialize() { register(this::onEvent1); } } Works fine against the latest lambda compiler (after yesterday push). Thanks Maurizio On 28/06/13 18:27, Nick Williams wrote: > On Jun 27, 2013, at 2:35 AM, Maurizio Cimadamore wrote: > >> On 26/06/13 18:43, Nick Williams wrote: >>> However, I CAN do this (it compiles and runs just fine): >>> >>> register(new ApplicationListener() { >>> public void onApplicationEvent(Event1 event) { } >>> }); >>> >>> So, by extension, I SHOULD be able to do this, but can't: >>> >>> void onApplicationEvent(Event1 event) { } >>> register(this::onApplicationEvent); >>> >>> We have inconsistent behavior here. In your example, both the method reference and the anonymous inner class are illegal. In my use case, the compiler allows the anonymous inner class but prohibits the method reference. That inconsistency is a real problem. There is_no_ semantic difference between what I'm doing with the anonymous inner class and what I'm doing with the method reference. Zero. The method signatures are identical (I event named them the same here to drive home the point), but one works and the other doesn't. >>> >>> Nick >>> >> Yes and no - the inner class you are creating is a subtype of: >> >> ApplicationListener >> >> while the type inferred by the compler as a target is: >> >> ApplicationListener (wildcard removed as per spec) >> >> This is why you get the 'weird' behavior. To express what you mean, you need to do the following: >> >> public static void register(ApplicationListener listener) { } >> >> The compiler will infer Z == Event1 and all will be fine. Well, it will fail with an inference error for now, but we have plans to fix that in the future. >> >> Maurizio > So, just so that I know I understand you correctly, you're saying that if I want to do it like this (which is something I tried previously and it did not work): > > public static void register(ApplicationListener listener) { } > public void onEvent1(Event1 event1) { } > public void initialize() { > register(this::onEvent1); > } > > I SHOULD be able to do this and I WILL be able to do this at some point before Java 8 is complete, but right now it's just not working. > > Do I understand that correctly? > > Nick > From ali.ebrahimi1781 at gmail.com Sat Jun 29 05:59:22 2013 From: ali.ebrahimi1781 at gmail.com (Ali Ebrahimi) Date: Sat, 29 Jun 2013 17:29:22 +0430 Subject: hg: lambda/lambda/langtools: 8016175: Add bottom-up type-checking support for unambiguous method references In-Reply-To: <51CECB01.3020503@oracle.com> References: <20130628105632.7291A48638@hg.openjdk.java.net> <51CECB01.3020503@oracle.com> Message-ID: Hi, On Sat, Jun 29, 2013 at 4:24 PM, maurizio cimadamore < maurizio.cimadamore at oracle.com> wrote: > On 28-Jun-13 5:59 PM, Ali Ebrahimi wrote: > > Hi Maurizio, > In test MethodReference71 I don't get why g(this::m2) is ambiguous. > please clarify this for me. thanks in advance. > > > It's not ambiguous, sorry for the typo in the test; however it's > erroneous, as the compiler doesn't have enough information to type-check > the method reference. > I think this is more than typo in test case since test output file says other thing. however, I have not tried that yet. +++ b/test/tools/javac/lambda/MethodReference71.out Fri Jun 28 11:54:17 2013 +0100 @@ -0,0 +1,3 @@ +MethodReference71.java:24:10: compiler.err.ref.ambiguous: g, kindname.method, g(MethodReference71.F), MethodReference71, kindname.method, g(MethodReference71.G), MethodReference71 +MethodReference71.java:24:11: compiler.err.prob.found.req: (compiler.misc.cyclic.inference: Z) +2 errors > > If, however, the method reference is unambiguous _and_ not a varargs (as > the first case), the compiler will go bottom up and 'unstick' the method > reference. > > We decided against the varargs case as, in the general case, that would > require support for disjunctive type inference, and we wanted to limit the > scope of the change at this point of the release. > so support for this case is on the desk for future. Ya? what about reverse case: class MethodReference71b { interface F { void m(X... x); } void m1(Integer i) { } void g(F f) { } void test() { g(this::m1); //? } } Best Regards Ali Ebrahimi From maurizio.cimadamore at oracle.com Sat Jun 29 06:23:48 2013 From: maurizio.cimadamore at oracle.com (Maurizio Cimadamore) Date: Sat, 29 Jun 2013 14:23:48 +0100 Subject: hg: lambda/lambda/langtools: 8016175: Add bottom-up type-checking support for unambiguous method references In-Reply-To: References: <20130628105632.7291A48638@hg.openjdk.java.net> <51CECB01.3020503@oracle.com> Message-ID: <51CEDFE4.9000602@oracle.com> On 29/06/13 13:59, Ali Ebrahimi wrote: > Hi, > > > On Sat, Jun 29, 2013 at 4:24 PM, maurizio cimadamore > > wrote: > > On 28-Jun-13 5:59 PM, Ali Ebrahimi wrote: >> Hi Maurizio, >> In test MethodReference71 I don't get why g(this::m2) is ambiguous. >> please clarify this for me. thanks in advance. > > It's not ambiguous, sorry for the typo in the test; however it's > erroneous, as the compiler doesn't have enough information to > type-check the method reference. > > I think this is more than typo in test case since test output file > says other thing. however, I have not tried that yet. Me bad for not opening the test - yes, the method reference is not ambiguous, but the enclosing method call is - so both 'g' are applicable, because the method reference isn't being type-checked in that case. > +++ b/test/tools/javac/lambda/MethodReference71.out Fri Jun 28 > 11:54:17 2013 +0100 > @@ -0,0 +1,3 @@ > +MethodReference71.java:24:10: compiler.err.ref.ambiguous: g, > kindname.method, g(MethodReference71.F), MethodReference71, > kindname.method, g(MethodReference71.G), MethodReference71 > +MethodReference71.java:24:11: compiler.err.prob.found.req: > (compiler.misc.cyclic.inference: Z) > +2 errors > > > If, however, the method reference is unambiguous _and_ not a > varargs (as the first case), the compiler will go bottom up and > 'unstick' the method reference. > > We decided against the varargs case as, in the general case, that > would require support for disjunctive type inference, and we > wanted to limit the scope of the change at this point of the release. > > so support for this case is on the desk for future. Ya? Well, yes - it's also a case of seeing how frequent that would be. We are quite confident that we should get good mileage out of current version, despite the limitations. The goal is to make the 'easy case' (which is also the most likely) work. > > what about reverse case: > > class MethodReference71b { > interface F { > void m(X... x); > } > > > void m1(Integer i) { } > > void g(F f) { } > > void test() { > g(this::m1); //? > } > > } Well, this case is erroneous; note that the method reference lookup will end up seraching for a method named 'm1' with an 'actual' of Z[]. Since there's only one 'm1' and that accepts an Integer, that's a type mismatch. That said, in this case the method reference is unambiguous and not a varargs, so it can be checked bottom up - only, doing so would result in a compile-time error - or at least it should, as I notice that your test crashes the compiler :-) Thanks Maurizio > > Best Regards > Ali Ebrahimi From tristan.yan at oracle.com Sat Jun 29 09:04:20 2013 From: tristan.yan at oracle.com (Tristan Yan) Date: Sat, 29 Jun 2013 09:04:20 -0700 (PDT) Subject: javac crash Message-ID: <7c908fff-728d-41e1-9fb6-6b75bdbbefbf@default> Is there anyone in compiler team who can look at this, this should report compilation error rather than compiler crash. import java.util.*; import java.util.stream.*; public class Crash { public void crash(U current, Stream stream) { List list3 = new ArrayList<>(); stream.forEach(i -> list3.add(current.clone())); } } javac Crash.java An exception has occurred in the compiler (1.8.0-internal). Please file a bug at the Java Developer Connection (http://java.sun.com/ webapps/bugreport) after checking the Bug Parade for duplicates. Include your program and the following diagnostic in your report. Thank you. java.lang.AssertionError: isSubClass U . Tristan Yan(Haibo Yan) Office : 8610-61066212 Fax : 8610-61065441 Cell : 86-18610696822 2F, Building No. 24, Zhongguancun Software Park Haidian District HYPERLINK "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6:P6_CITY:Beijing"Beijing , 100193 oracle From jonathan.gibbons at oracle.com Sat Jun 29 09:10:45 2013 From: jonathan.gibbons at oracle.com (Jonathan Gibbons) Date: Sat, 29 Jun 2013 09:10:45 -0700 Subject: javac crash In-Reply-To: <7c908fff-728d-41e1-9fb6-6b75bdbbefbf@default> References: <7c908fff-728d-41e1-9fb6-6b75bdbbefbf@default> Message-ID: <51CF0705.8030904@oracle.com> Tristan, You should include the stack trace as well. -- Jon On 06/29/2013 09:04 AM, Tristan Yan wrote: > Is there anyone in compiler team who can look at this, this should report compilation error rather than compiler crash. > > import java.util.*; > > import java.util.stream.*; > > > > public class Crash { > > public void crash(U current, Stream stream) { > > List list3 = new ArrayList<>(); > > stream.forEach(i -> list3.add(current.clone())); > > } > > } > > > > javac Crash.java > > An exception has occurred in the compiler (1.8.0-internal). Please file a bug at the Java Developer Connection (http://java.sun.com/ > > webapps/bugreport) after checking the Bug Parade for duplicates. Include your program and the following diagnostic in your report. > > Thank you. > > java.lang.AssertionError: isSubClass U > > . > > > > Tristan Yan(Haibo Yan) > > Office : 8610-61066212 > > Fax : 8610-61065441 > > Cell : 86-18610696822 > > > > 2F, Building No. 24, Zhongguancun Software Park > > Haidian District HYPERLINK "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6:P6_CITY:Beijing"Beijing , 100193 > > oracle > > > > From maurizio.cimadamore at oracle.com Sat Jun 29 09:24:55 2013 From: maurizio.cimadamore at oracle.com (Maurizio Cimadamore) Date: Sat, 29 Jun 2013 17:24:55 +0100 Subject: javac crash In-Reply-To: <7c908fff-728d-41e1-9fb6-6b75bdbbefbf@default> References: <7c908fff-728d-41e1-9fb6-6b75bdbbefbf@default> Message-ID: <51CF0A57.6090503@oracle.com> Thanks, I think I have a fix - will push it next week. Maurizio On 29/06/13 17:04, Tristan Yan wrote: > Is there anyone in compiler team who can look at this, this should report compilation error rather than compiler crash. > > import java.util.*; > > import java.util.stream.*; > > > > public class Crash { > > public void crash(U current, Stream stream) { > > List list3 = new ArrayList<>(); > > stream.forEach(i -> list3.add(current.clone())); > > } > > } > > > > javac Crash.java > > An exception has occurred in the compiler (1.8.0-internal). Please file a bug at the Java Developer Connection (http://java.sun.com/ > > webapps/bugreport) after checking the Bug Parade for duplicates. Include your program and the following diagnostic in your report. > > Thank you. > > java.lang.AssertionError: isSubClass U > > . > > > > Tristan Yan(Haibo Yan) > > Office : 8610-61066212 > > Fax : 8610-61065441 > > Cell : 86-18610696822 > > > > 2F, Building No. 24, Zhongguancun Software Park > > Haidian District HYPERLINK "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6:P6_CITY:Beijing"Beijing , 100193 > > oracle > > > > From tristan.yan at oracle.com Sun Jun 30 01:40:46 2013 From: tristan.yan at oracle.com (Tristan Yan) Date: Sun, 30 Jun 2013 01:40:46 -0700 (PDT) Subject: Shall we add compose/andThen to IntFunction/LongFunction Message-ID: <0b6e6eca-900b-4219-a72e-c237cf990637@default> I understand why IntFunction/LongFunction doesn't inherit Function, but this makes IntFunction/LongFunction doesn't have compose/andThen methods. Do we have plan to add them? Thank you Tristan Yan(Haibo Yan) Office : 8610-61066212 Fax : 8610-61065441 Cell : 86-18610696822 2F, Building No. 24, Zhongguancun Software Park Haidian District HYPERLINK "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6:P6_CITY:Beijing"Beijing , 100193 oracle From brian.goetz at oracle.com Sun Jun 30 06:42:02 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Sun, 30 Jun 2013 09:42:02 -0400 Subject: Shall we add compose/andThen to IntFunction/LongFunction In-Reply-To: <0b6e6eca-900b-4219-a72e-c237cf990637@default> References: <0b6e6eca-900b-4219-a72e-c237cf990637@default> Message-ID: <51D035AA.9020507@oracle.com> IntUnaryOperator (int -> int) and friends do. But the mixed functions like IntFunction (int -> T) would arguably need multiple compose functions for different types, which then ask for overload ambiguities. On 6/30/2013 4:40 AM, Tristan Yan wrote: > I understand why IntFunction/LongFunction doesn't inherit Function, but this makes IntFunction/LongFunction doesn't have compose/andThen methods. Do we have plan to add them? > > > > Thank you > > Tristan Yan(Haibo Yan) > > Office : 8610-61066212 > > Fax : 8610-61065441 > > Cell : 86-18610696822 > > > > 2F, Building No. 24, Zhongguancun Software Park > > Haidian District HYPERLINK "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6:P6_CITY:Beijing"Beijing , 100193 > > oracle > > > > > > From tristan.yan at oracle.com Sun Jun 30 06:50:17 2013 From: tristan.yan at oracle.com (Tristan Yan) Date: Sun, 30 Jun 2013 06:50:17 -0700 (PDT) Subject: =?gb2312?B?tPC4tDogU2hhbGwgd2UgYWRkIGNvbXBvc2UvYW5kVGg=?= =?gb2312?B?ZW4gdG8gSW50RnVuY3Rpb24vTG9uZ0Z1bmN0aW9u?= In-Reply-To: <51D035AA.9020507@oracle.com> References: <0b6e6eca-900b-4219-a72e-c237cf990637@default> <51D035AA.9020507@oracle.com> Message-ID: <6fcb3eb4-2e74-4170-8744-8e3ef1a8258d@default> Does this imply I should use Function rather than IntFunction if I need do compose/andThen? Thank you -----????----- ???: Brian Goetz ????: Sunday, June 30, 2013 9:42 PM ???: Tristan Yan ??: lambda-dev at openjdk.java.net ??: Re: Shall we add compose/andThen to IntFunction/LongFunction IntUnaryOperator (int -> int) and friends do. But the mixed functions like IntFunction (int -> T) would arguably need multiple compose functions for different types, which then ask for overload ambiguities. On 6/30/2013 4:40 AM, Tristan Yan wrote: > I understand why IntFunction/LongFunction doesn't inherit Function, but this makes IntFunction/LongFunction doesn't have compose/andThen methods. Do we have plan to add them? > > > > Thank you > > Tristan Yan(Haibo Yan) > > Office : 8610-61066212 > > Fax : 8610-61065441 > > Cell : 86-18610696822 > > > > 2F, Building No. 24, Zhongguancun Software Park > > Haidian District HYPERLINK > "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6 > :P6_CITY:Beijing"Beijing , 100193 > > oracle > > > > > > From brian.goetz at oracle.com Sun Jun 30 07:16:46 2013 From: brian.goetz at oracle.com (Brian Goetz) Date: Sun, 30 Jun 2013 10:16:46 -0400 Subject: =?UTF-8?B?562U5aSNOiBTaGFsbCB3ZSBhZGQgY29tcG9zZS9hbmRUaGVuIHQ=?= =?UTF-8?B?byBJbnRGdW5jdGlvbi9Mb25nRnVuY3Rpb24=?= In-Reply-To: <6fcb3eb4-2e74-4170-8744-8e3ef1a8258d@default> References: <0b6e6eca-900b-4219-a72e-c237cf990637@default> <51D035AA.9020507@oracle.com> <6fcb3eb4-2e74-4170-8744-8e3ef1a8258d@default> Message-ID: <51D03DCE.7010101@oracle.com> It depends what you care about most :) The compose/andThen methods are trivially to manually inline. Using Function instead of IntFunction will involve more boxing. Maybe you care, maybe you don't. If you don't, compose is fine here. If you do, you'll manually inline: t -> secondFn.apply(firstFn.apply(t)); On 6/30/2013 9:50 AM, Tristan Yan wrote: > Does this imply I should use Function rather than IntFunction if I need do compose/andThen? > Thank you > > -----????----- > ???: Brian Goetz > ????: Sunday, June 30, 2013 9:42 PM > ???: Tristan Yan > ??: lambda-dev at openjdk.java.net > ??: Re: Shall we add compose/andThen to IntFunction/LongFunction > > IntUnaryOperator (int -> int) and friends do. But the mixed functions like IntFunction (int -> T) would arguably need multiple compose functions for different types, which then ask for overload ambiguities. > > On 6/30/2013 4:40 AM, Tristan Yan wrote: >> I understand why IntFunction/LongFunction doesn't inherit Function, but this makes IntFunction/LongFunction doesn't have compose/andThen methods. Do we have plan to add them? >> >> >> >> Thank you >> >> Tristan Yan(Haibo Yan) >> >> Office : 8610-61066212 >> >> Fax : 8610-61065441 >> >> Cell : 86-18610696822 >> >> >> >> 2F, Building No. 24, Zhongguancun Software Park >> >> Haidian District HYPERLINK >> "http://people.us.oracle.com/pls/oracle/f?p=8000:6:396067987304343:::6 >> :P6_CITY:Beijing"Beijing , 100193 >> >> oracle >> >> >> >> >> >>