Similar to #13883, the immutable dictionary and set collections are likely not balancing their AVL trees properly.
We should first copy and adapt the tests from ImmutableList that highlighted this bug to the other collection types' tests and then apply the same fix.

Forward, Backward, Up, Down, Left, Right public properties for Matrix4x4

I've got HP laptop with windows 7. When I run build.cmd, I've got the error "configuration is invalid"

C:\Projects\dotnet\corefx>build.cmd
C:\Projects\dotnet\corefx\src\System.Collections.Immutable.sln.metaproj : error MSB4126: указанная конфигурация решения "Release|MCD" недопустима. Укажите допустимую конфигурац
ию решения с помощью свойств Configuration и Platform (например, MSBuild.exe Solution.sln /p:Configuration=Debug /p:Platform="Any CPU") или оставьте эти свойства пустыми, чтобы
использовать конфигурацию решения по умолчанию. [C:\Projects\dotnet\corefx\src\System.Collections.Immutable.sln]

The reason of this error is that environment variable Platform is set to MCD on the laptop by default. I have to change build command in the build.cmd by adding /p:Platform="Any CPU" to compile the project.

Build script should check for allowed platforms and generate user-friendly error message, which says what to do to successfully compile the project when the platform is not supported.

According to https://github.com/Microsoft/dotnet/blob/master/CONTRIBUTING.md "readolny" should be used when possible and I think it isn't for example in System.Numerics Matrix3x2

Would the maintainers be interested in Travis/Coveralls integration so the test coverage is more visible?

The current source includes public static methods for reflection of a vector about a unit vector normal but the underlying vector projection is also useful by itself.

Proposing:

public static Vector2 Project(Vector2 vector, Vector2 component) { ... }
//...
public static Vector3 Project(Vector3 vector, Vector3 component) { ... }

I'll wait for feed back before trying to submit a pull request.

When the cache is removing items due to memory pressure it currently considers:

1. Expired
2. Priority
3. LRU

Also consider:

• TTL - How long does this item have to live before time based expiration? Sliding vs Absolute.
• Estimated object (graph) size
• Others?

Hello,

I've noted that some files likely need the due header with copyright and license statement. Example:
https://github.com/dotnet/corefx/blob/master/src/System.Reflection.Metadata/tests/Resources/NetModule/ModuleCS01.cs

Likely missing a header as:

// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

The header helps with the provenance task when these files get separated from the original development. From what I can tell, these aren't auto-generated files, just normal source code.

Affected files:

./src/System.Reflection.Metadata/tests/Resources/NetModule/ModuleCS00.cs
./src/System.Reflection.Metadata/tests/Resources/NetModule/ModuleCS01.cs
./src/System.Reflection.Metadata/tests/Resources/NetModule/ModuleVB01.vb
./src/System.Reflection.Metadata/tests/Resources/Namespace/NamespaceForwardedCS.cs
./src/System.Reflection.Metadata/tests/Resources/Namespace/NamespaceTests.cs
./src/System.Reflection.Metadata/tests/Resources/Misc/CPPClassLibrary2.h
./src/System.Reflection.Metadata/tests/Resources/Misc/Members.cs
./src/System.Reflection.Metadata/tests/Resources/Interop/Interop.Mock01.cs
./src/System.Reflection.Metadata/tests/Resources/Interop/Interop.Mock01.Impl.cs
./src/System.Collections.Immutable/tests/PinnedImmutableArrayTests.cs

Not sure if these files count as authored code:

./src/System.Reflection.Metadata/tests/Resources/Interop/IndexerWithByRefParam.il
./src/System.Numerics.Vectors/tests/GenericVectorTests.tt
./src/System.Numerics.Vectors/src/System/Numerics/ConstantHelper.tt
./src/System.Numerics.Vectors/src/System/Numerics/Register.tt
./src/System.Numerics.Vectors/src/System/Numerics/Vector.tt

With kind regards,
Nuno Brito

Some of Xml tests were testing problematic characters in different Encoding (like Russian characters). At some point few years back the encoding was lost while moving between different repos. Tests pass because .cs files lost their encoding too. Tests need to be rewritten since there is no trace of original copy

System.Xml.XmlReader is currently missing.

Not sure what the timeline or exact approach is but it seems that packages are pushed to master when they seem to be complete enough.

It would be very nice to open up a develop branch that contains the active flux state of all the published packages posted here: https://www.myget.org/gallery/aspnetrelease (or here https://www.myget.org/gallery/aspnetvnext whichever reflect develop).

Since we are trying these packages right now it'd be great to follow their development more closely as well.

For instance right now I can't locate NameValueCollection or StringComparison.InvariantCulture anywhere in the available packages and by waiting for packages to drip into master I fear that there will be no time window before the GA of the corefx where we can report these missing features.

A build.sh should be added alongside build.cmd to build corefx on Linux/Mac.

MetadataReader.GetString now uses the Encoding provided via MetadataStringDecoder.Encoding or falls back to Encoding.UTF8 if none is provided.

However, MetadataStringComparer still uses a custom UTF-8 implementation, which does not handle errors correctly and prevents any customization of the fallback behaviour.

Care must be taken when making this change to not allocate as that is essentially the entire point of MetadataStringComparer.

I know that cross-platform support is coming later, I just thought it might make sense to document this here in case someone else tries the same

Building System.Xml.sln with xbuild on Mono doesn't work (the other solutions build fine), it throws the following errors:

Build FAILED.
Errors:

/home/alexander/dev/corefx/src/System.Xml.sln (default targets) ->
(Build target) ->
/home/alexander/dev/corefx/src/System.Xml.XPath.XDocument/System.Xml.XPath.XDocument.csproj (default targets) ->
/usr/lib/mono/4.5/Microsoft.CSharp.targets (CoreCompile target) ->

    System/Xml/XPath/XAttributeExtensions.cs(10,56): error CS0433: The imported type `System.Xml.Linq.XAttribute' is defined multiple times
    System/Xml/XPath/XAttributeExtensions.cs(10,78): error CS0433: The imported type `System.Xml.Linq.XNamespace' is defined multiple times
    System/Xml/XPath/XDocumentExtensions.cs(22,61): error CS0433: The imported type `System.Xml.Linq.XNode' is defined multiple times
    System/Xml/XPath/XObjectExtensions.cs(10,23): error CS0433: The imported type `System.Xml.Linq.XContainer' is defined multiple times
    System/Xml/XPath/XObjectExtensions.cs(10,49): error CS0433: The imported type `System.Xml.Linq.XObject' is defined multiple times
    System/Xml/XPath/XNodeNavigator.cs(48,9): error CS0433: The imported type `System.Xml.Linq.XElement' is defined multiple times
    System/Xml/XPath/XNodeNavigator.cs(784,35): error CS0433: The imported type `System.Xml.Linq.XText' is defined multiple times

It looks like it runs into a conflict with the System.Xml.Linq library in the Mono GAC. Needs further investigation.

The following XPath tests fail for me on Windows 10 Technical Preview, build 9879:

StringFunctionsTest2457
StringFunctionsTest2458

The call to Convert.ChangeType in XPathTests.Common.Utils.XPathObject is throwing a FormatException when the value passed is "Infinity" or "-Infinity".

The tests pass for me on Windows 8.1. Each of these tests is part of 3 different test assemblies, resulting in 6 failures total:

System.Xml.XPath.Tests.dll
System.Xml.XPath.XDocument.Tests.dll
System.Xml.XPath.XmlDocument.Tests.dll

I tried to build Mono.Posix against aspnetcore50 and found a lot of API that mono uses to be missing from .NET Core most prominently in the Interop-domain (like CustomMarshaler).

Please add Mono.Posix to your list of scenarios that can benefit from the API surface of .NET Core.

(reported via [email protected] from Jay Sulzberger)
In the file

https://github.com/dotnet/corefx/blob/master/src/System.Numerics.Vectors/src/Properties/AssemblyInfo.cs

there is no mention of the MIT License, under which, according to press accounts, Dotnet Core is now licensed. Rather we have this line:

[assembly: AssemblyCopyright("\x00a9 Microsoft Corporation. All rights reserved.")]

which is line 14 by Github's count.

I think this is just a typo.

When you reference files outside the project directory, such as the common directory in the XML code case, these links by default show up in the root of the project in VS which is very annoying and clutters the solution unnecessarily. We should add the appropriate metadata to these Compile items so that VS will group them correctly in the solution explorer.

The overloads of Create have incorrect return documentation. They all claim to return a '1-element array' when in fact it is 1,2,3 and 4.

After pulling both of @adamralph 's pull requests dotnet/corefx#31 and dotnet/corefx#32, I'm continuing to see test failures for SIMD on a DEU (German) test environment.

Here's a representative error:
d:\oss\corefx\src\System.Numerics.Vectors\tests\GenericVectorTests.cs(545): error : System.Numerics.Tests.GenericVe
ctorTests.ToStringCurrencySByte: Assert.Equal() Failure\r\nPosition: First difference is at position 8\r\nExpected:
<97,00 ?, -108,00 ?, 22,00 ?, 29,00 ?, 49,00 ?, 60,00 ?, 103,00 ?, 58,00 ?, -62,00 ?, -124,00 ?, -117,00 ?, 48,00
?, 15,00 ?, -35,00 ?, -13,00 ?, -34,00 ?>\r\nActual: <97,00 ?. -108,00 ?. 22,00 ?. 29,00 ?. 49,00 ?. 60,00 ?. 103
,00 ?. 58,00 ?. -62,00 ?. -124,00 ?. -117,00 ?. 48,00 ?. 15,00 ?. -35,00 ?. -13,00 ?. -34,00 ?> [D:\oss\corefx\bin
tools\fxbuild.proj]

Observe that expected separates elements with a comma, actual separates elements with a dot.

C:\repo\cacheprototype\corefx>build.cmd
Unable to resolve dependency 'xunit.runners (≥ 2.0.0-beta4-build2738)'.
C:\repo\cacheprototype\corefx\build.proj(80,5): error MSB3073: The command ""C:
\repo\cacheprototype\corefx\bin\tools\NuGet.exe" install Microsoft.DotNet.Build
Tools -Prerelease -Version 1.0.13-prerelease -o " C:\repo\cacheprototype\corefx
\src\packages\ " -ConfigFile "C:\repo\cacheprototype\corefx\src\nuget\NuGet.Con
fig"" exited with code 1.

C:\repo\cacheprototype\corefx>"C:\repo\cacheprototype\corefx\bin\tools\NuGet.exe
" install Microsoft.DotNet.BuildTools -Prerelease -Version 1.0.13-prerelease -o
" C:\repo\cacheprototype\corefx\src\packages\ " -ConfigFile "C:\repo\cacheprotot
ype\corefx\src\nuget\NuGet.Config"
Attempting to resolve dependency 'xunit.runners (≥ 2.0.0-beta4-build2738)'.
Unable to resolve dependency 'xunit.runners (≥ 2.0.0-beta4-build2738)'.

But its very strange as the package exists on nuget.org. Perhaps it is really a nuget bug.

This isn't exactly an issue, but I noticed there are a lot of unused "using" statements in the code. Is there any reason not to remove them?
Now I know that these don't actually lower the performance but it would make the code a lot easier to read (at least for me).

If I launch a normal command prompt and run the build.cmd, build fails with
F:\GitHub\corefx>build.cmd
C:\Program Files (x86)\MSBuild\12.0\bin\Microsoft.Common.CurrentVersion.targets(989,5): warning MSB3644: The reference assemblies for framework ".NETPortable,Version=v4.5,Profile=Profile259" were not found. To resolve this, install the SDK or Targeting Pack for this framework version or retarget your application to a version of the framework for which you have the SDK or Targeting Pack installed. Note that assemblies will be resolved from the Global Assembly Cache (GAC) and will be used in place of reference assemblies. Therefore your assembly may not be correctly targeted for the framework you intend. [F:\GitHub\corefx\src\System.Collections.Immutable\src\System.Collections.Immutable.csproj]
C:\Program Files (x86)\MSBuild\12.0\bin\Microsoft.Common.CurrentVersion.targets(1635,5): warning MSB3270: There was a mismatch between the processor architecture of the project
being built "MSIL" and the processor architecture of the reference "C:\windows\Microsoft.NET\Framework\v4.0.30319\mscorlib.dll", "x86". This mismatch may cause runtime failur
.....

README.md has to be updated with the correct instructions as to how the command prompt needs to be brought up

There are few projects so far, When we could get full corefx package?

Spelling error on line 40

constaints should be contains

Could not locate it in any of the available packages:

http://msdn.microsoft.com/en-us/library/system.iconvertible(v=vs.95).aspx

Howdy from The Changelog!

This message is for Immo Landwerth (@terrajobst) or anyone else on the team at Microsoft who might be able help us to coordinate a call on The Changelog to talk about open sourcing .NET Core.

The Changelog is a podcast covering what's fresh and new in open source. Listen to the show here http://thechangelog.com/podcast/ or here http://5by5.tv/changelog

Looking forward to talking to y'all!

Adam, EIC

Some tests (especially slow tests) do not belong to the idea of inner loop tests (aka unit tests).
We should have a consistent way of deciding which are inner and which are outer loop tests.

List of disabled tests (XPath.XDocument):
AttributeSpecifiedTest
AxesCombinationsTest2104
AxesCombinationsTest2155
AxesCombinationsTest2201
AxesCombinationsTest2202
AxesCombinationsTest2205
AxesCombinationsTest2206
AxesCombinationsTest2208
AxesCombinationsTest2210
AxesCombinationsTest2211
AxesCombinationsTest2214
AxesCombinationsTest2220
AxesCombinationsTest23
AxesCombinationsTest232
AxesCombinationsTest233
AxesCombinationsTest24
AxesCombinationsTest240
AxesCombinationsTest248
AxesCombinationsTest262
AxesCombinationsTest264
AxesCombinationsTest265
AxesCombinationsTest266
AxesCombinationsTest268
AxesCombinationsTest288
AxesCombinationsTest289
AxesCombinationsTest290
AxesTest1271
AxesTest1272
BooleanFunctionsTest2518
ComplexExpressionsTest312
ComplexExpressionsTest319
ComplexExpressionsTest32
ComplexExpressionsTest320
ComplexExpressionsTest321
ComplexExpressionsTest324
ComplexExpressionsTest329
ComplexExpressionsTest330
ComplexExpressionsTest331
ComplexExpressionsTest337
ComplexExpressionsTest340
ComplexExpressionsTest523
ComplexExpressionsTest53
ComplexExpressionsTest54
ComplexExpressionsTest56
GlobalizationTest566
LongElementName
MatchesTest1164
MatchesTest1167
PredicatesTest1072
UsingPositionFunctionTest663

some of the files I looked up, it has header comment with Apache 2.0 license.
which license should apply for those files? MIT or Apache 2.0

DISCUSSION MOVED to forums: http://forums.dotnetfoundation.org/t/performance-testing-best-practices/410 (per project guidance)

(on behalf of CLR perf team)
We are fishing for best practices how to do performance tests in open source projects and for cross-platform.
We have bunch of reusable practices home-grown, but they heavily depend on monitoring on certified dedicated machines in our perf lab (i.e. no other process/disk IO interaction).

Any pointers how other open source projects deal with perf test suites in their CI systems?

What we do today in-house:
There's a set of tests. Many of them are microbenchmarks, they are the easiest: Each microbenchmark is wrapped in runner which warms up the scenario, then runs it 5 times and measures the time. It prints the result with some basic statistics to the output/log. A tool then parses all the logs and displays them (through a DB) in HTML-based UI with history (graphs for trends, etc.).
Currently we run it on the same dedicated machines, so results are comparable and one can reason about changes over time.

What we could do:
Keep running tests on dedicated machines and publish results somewhere. Is that the best practice?
To support dev scenario on local box we could generalize the infrastructure to run on any machine and provide a tool that compares 2 runs (baseline vs. PR), so any dev can check impact on performance prior to PR if there's perf risk.

When Insert is called in ImmutableList, the list is not always balanced correctly by the MakeBalanced method. This was exposed PR dotnet/corefx#67. I have created a minimal test which exposes this bug and will create a separate PR to correct this.

Thought I'd dive into some of the stuff that's been shipped and but I'm greeted by this error:

C:\Users\brendanforster\Documents\windows\corefx [master]> .\build
  Unable to resolve dependency 'xunit.runners (≥ 2.0.0-beta4-build2738)'.
C:\Users\brendanforster\Documents\windows\corefx\build.proj(80,5): error MSB3073: The command ""C:\Users\brendanforster
\Documents\windows\corefx\bin\tools\NuGet.exe" install Microsoft.DotNet.BuildTools -Prerelease -Version 1.0.13-prerelea
se -o " C:\Users\brendanforster\Documents\windows\corefx\src\packages\ " -ConfigFile "C:\Users\brendanforster\Documents
\windows\corefx\src\nuget\NuGet.Config"" exited with code 1.

I can see that Microsoft.DotNet.BuildTools is now unlisted but that doesn't seem to be what this error indicates. I can also see that a new version of the xUnit package - 2.0.0-beta5-build2785 - was released recently, but that shouldn't be a problem either.

Repro steps:

• git checkout 83862782
• git clean -xdf
• .\build

Some XPath.XDocument queries have different results than other XPath navigators.
This might be an old behavior or newly introduced bug.

Failing tests:
build /p=IncludeTraits=ActiveIssue=17

Is there a reason that the Quaternion struct has public exposed fields versus read only properties? Seems to be against the general guidelines for structs and immutability. Why would you want to allow X, Y, Z and W to be set outside of the ctor?

Hello,

As i'm French, my CultureInfo.CurrentCulture is set to "fr-FR" while running tests.
But for some tests, especially for the ToString() methods, tests are write to check "en-US" Culture.

This: if (o.Annotations() != null)
is always true because the above while can finish only in two conditions: when o != null or when o.annotations == null. The first condition will be catched by " if (o == null)" and if the second one is true, "o.Annotations() != null" will also always be true i think.

Quaternion declares a handful of methods to perform addition, subtraction and multiplication, and provides the respective overloads for these operations.

However, instead of re-using the Add, Multiply etc. methods, the code is re-written in the operator overloads. The operators should be using their respective methods rather than re-declaring the same code.

This is under the assumption that the JIT inlines the methods when they are used in the operator overloads.

The built in floating point types compare NaN as unequal when using == and != (following IEEE semantics) but compare it as equal when using the Equals method.

Your floating point based types currently use IEEE semantics even for Equals. I suggest using the same behaviour as the built in types in your floating point based types like vectors or quaternions.

The MSDN documentation of Equals contains an exception that allows A.Equals(A) to return false on floating point types, so you don't strictly violate its contract.
But returning false still breaks hash tables and does not match the behaviour of the built in types, so I consider it a bad idea.

This can be avoided by calling Equals on the members instead of == in the implementation of Equals but not in == and !=.

For example with quaternion,

replace

public bool Equals(Quaternion other)
{
    return (X == other.X &&
            Y == other.Y &&
            Z == other.Z &&
            W == other.W);
}

with

public bool Equals(Quaternion other)
{
    return (X.Equals(other.X) &&
            Y.Equals(other.Y) &&
            Z.Equals(other.Z) &&
            W.Equals(other.W));
}

You might want to add tests that check that == and != compare all the above cases as unequal, so that they match the IEEE specification.

Replace:

// Counterintuitive result - IEEE rules for NaN comparison are weird!
Assert.False(a.Equals(a));
Assert.False(b.Equals(b));
Assert.False(c.Equals(c));
Assert.False(d.Equals(d));

with:

// Equals does not follow IEEE semantics since many consumers rely on equality being reflexive.
// This includes collections like `Dictionary<K,V>` or `HashSet<T>`
Assert.True(a.Equals(a));
Assert.True(b.Equals(b));
Assert.True(c.Equals(c));
Assert.True(d.Equals(d));

// Counterintuitive result - IEEE rules for NaN comparison are weird!
Assert.False(a == a);
Assert.False(b == b);
Assert.False(c == c);
Assert.False(d == d);

Assert.True(a != a);
Assert.True(b != b);
Assert.True(c != c);
Assert.True(d != d);

XPath.XDocument navigator doesn't support MoveToId(string).

Verify if this was ever supported.
If it was, verify if we want to support it in the future.
If it wasn't move the tests to a different file and remove them from XPath.XDocument.Tests project.

Failing tests:
NodeSetFunctionsTest2267
MatchesTest2352

This should come in handy for testing PRs.

What kind of consideration is being made for replacements for/changes to existing features or APIs that the broader community may consider a pain point?

For example, in Java the Calendar/Date classes were considered a mess, with many developers preferring the excellent Joda-Time library. With Java 8, the Joda-Time developers contributed a new date/time API, JSR-310 (although, curiously, the old classes haven't been deprecated yet).

Apparently .NET has its own date/time problems (although I haven't used the platform/C# enough to run into issues myself). What would the process be for submitting such broad-scoped, potential replacement features (whether by the NodaTime team, or others)?

Java has the JCP for managing this sort of thing, including reviews of such proposals. Is there something similar planned for .NET (because the platform itself was only recently open-sourced), or is it I just don't know where to find such a thing? After all, it would get a bit confusing to have multiple people working on divergent versions of such new features...

The resulting quaternion depends on the length of axis. This does not describe a rotation and thus does not match the documentation.

There are a few ways to handle this issue:

1. Normalize axis, but this incurs a performance hit

2. Add a precondition that axis.Length() ≈ 1.

   But enforcing that pre-condition is about as expensive as 1), so it'd probably need to be a documentation-only precondition. Unfortunately this means that consumers will rely on the current behaviour even if it's undocumented, so I don't think that this is a good solution.

3. Document the current behaviour

Just for convenience, the relevant source code:

/// <summary>
/// Creates a Quaternion from a vector and an angle to rotate about the vector.
/// </summary>
/// <param name="axis">The vector to rotate around.</param>
/// <param name="angle">The angle, in radians, to rotate around the vector.</param>
/// <returns>The created Quaternion.</returns>
public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle)
{
    Quaternion ans;

    float halfAngle = angle * 0.5f;
    float s = (float)Math.Sin(halfAngle);
    float c = (float)Math.Cos(halfAngle);

    ans.X = axis.X * s;
    ans.Y = axis.Y * s;
    ans.Z = axis.Z * s;
    ans.W = c;

    return ans;
}

Hi,

I cloned recently the Corefx Repo, and i was able to build it using the build.cmd and all tests were Green.

But when i ran the tests from visual studio 2013 for the System.Reflection.Metadata solution, using the Debug configuration, all tests based on System.Reflection.Internal.EncodingHelper.DecodeUtf8Prefixed method failed, after disassembling the assembly, the code looks like bellow, so the function returns always (null | String.Empty) :

The code disassembled based on the Release config is shown below :

So, to make this code working, and tests success on both configurations, i updated this function. Now the results of the disassembled code looks like bellow:

Debug version :

Release version :

So, if you have this same behavior, and this fix is legitim. Let me kwow if i have to push this change.

Hi all

I just started wading into the new awesome pool. It is fantastic to see this!

The first thing I hit were the contrib guidelines in particular around coding style:

"We always specify the visibility, even if it's the default (i.e. private string _foo not string _foo)"

And then I started looking at the code and it is clearly not following this rule, example

Jumping around it looks pretty rampant that there visibility is not present. Most likely an automated tool needs to run through the code for consistency. Any plans to do this?

If not, then what happens if one does a PR to a class that already has private members without visibility declared and they add new ones?

I shudder to suggest the next point, but if the rule is serious it might be good to have an automated tool scrubbing going forward for consistency.

Or.....drop the rule :-)

I've found some typos in comments in various places, I'll do a pull request soon (created issue as per contributing guidelines).

Feature request: please add "Hello, World!" sample, which shows how to use .NET Core with user applications.

Two of the tests in our System.Numerics.Vectors suite are failing only on our CI build server, and potentially only intermittently:

Vector2NormalizeTest1
Vector4NormalizeTest2

Given that these are very similar to other tests which cover a similar edge-case (especially the Vector3 normalization tests, which aren't failing), we will need to investigate why these tests in particular are failing on our build server. This may have been a point-in-time issue as we brought up our build infrastructure, and may not re-surface again.

Spelling Error on System.Reflection line 35

th should be the.

Up, Down, Left, Right, Forward, Backward vector public static properties