Corrected titles and headings (dotnet#690)

- one H1 per article
- removed - from metadata
- added missing # to titles

Author: svick

docs/core/deploying/creating-nuget-packages.md

@@ -12,7 +12,7 @@ ms.devlang: dotnet
 ms.assetid: 2f0415c1-110b-433d-87c1-ae3d543a8844
 ---
 
-## How to Create a NuGet Package with Cross Platform Tools
+# How to Create a NuGet Package with Cross Platform Tools
 
 > **Note:** The following shows command-line samples using unix.  The `dotnet pack` command as shown here works the same way on Windows.
 
@@ -58,4 +58,4 @@ And now you have the necessary files to publish a NuGet package!
 
 ## Don't confuse `dotnet pack` with `dotnet publish`
 
-It is important to note that at no point is the `dotnet publish` command involved.  The `dotnet publish` command is for deploying applications with all of their dependencies in the same bundle -  not for generating a NuGet package to be distributed and consumed via NuGet.
+It is important to note that at no point is the `dotnet publish` command involved.  The `dotnet publish` command is for deploying applications with all of their dependencies in the same bundle -  not for generating a NuGet package to be distributed and consumed via NuGet.

docs/core/deploying/index.md

@@ -1,15 +1,15 @@
 ---
--title: .NET Core Application Deployment 
--description: .NET Core Application Deployment 
--keywords: .NET, .NET Core, .NET Core deployment
--author: rpetrusha
--manager: wpickett
--ms.date: 06/20/2016
--ms.topic: article
--ms.prod: .net-core
--ms.technology: .net-core-technologies
--ms.devlang: dotnet
--ms.assetid: da7a31a0-8072-4f23-82aa-8a19184cb701
+title: .NET Core Application Deployment 
+description: .NET Core Application Deployment 
+keywords: .NET, .NET Core, .NET Core deployment
+author: rpetrusha
+manager: wpickett
+ms.date: 06/20/2016
+ms.topic: article
+ms.prod: .net-core
+ms.technology: .net-core-technologies
+ms.devlang: dotnet
+ms.assetid: da7a31a0-8072-4f23-82aa-8a19184cb701
 ---
 
 # .NET Core Application Deployment #

docs/core/index.md

@@ -12,8 +12,7 @@ ms.devlang: dotnet
 ms.assetid: f2b312cb-f80c-4b0d-9101-93908f06a6fa
 ---
 
-.NET Core
-=========
+# .NET Core
 
 > Check out the ["Getting Started" tutorials](tutorials/index.md) to learn how to create a simple .NET Core application. It only takes a few minutes to get your first app up and running.
 
@@ -28,8 +27,7 @@ The following characteristics best define .NET Core:
 - **Open source:** The .NET Core platform is open source, using MIT and Apache 2 licenses. Documentation is licensed under [CC-BY](http://creativecommons.org/licenses/by/4.0/). .NET Core is a [.NET Foundation](http://www.dotnetfoundation.org/) project.
 - **Supported by Microsoft:** .NET Core is supported by Microsoft, per [.NET Core Support](https://www.microsoft.com/net/core/support/)
 
-Composition
-===========
+## Composition
 
 .NET Core is composed of the following parts:
 
@@ -38,48 +36,41 @@ Composition
 - A [set of SDK tools](https://github.com/dotnet/cli) and [language compilers](https://github.com/dotnet/roslyn) that enable the base developer experience, available in the [.NET Core SDK](sdk.md).
 - The 'dotnet' app host, which is used to launch .NET Core apps. It selects the runtime and hosts the runtime, provides an assembly loading policy and launches the app. The same host is also used to launch SDK tools in much the same way.
 
-Languages
----------
+### Languages
 
 The C# language (F# and VB are coming) can be used to write applications and libraries for .NET Core. The compilers run on .NET Core, enabling you to develop for .NET Core anywhere it runs. In general, you will not use the compilers directly, but indirectly using the SDK tools.
 
 The C# Roslyn compiler and the .NET Core tools are or can be integrated into several text editors and IDEs, including Visual Studio, [Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=ms-vscode.csharp), Sublime Text and Vim, making .NET Core development an option in your favorite coding environment and OS. This integration is provided, in part, by the good folks of the [OmniSharp project](http://www.omnisharp.net/).
 
-.NET APIs and Compatibility
----------------------------
+### .NET APIs and Compatibility
 
 .NET Core can be thought of as a cross-platform version of the .NET Framework, at the layer of the .NET Framework Base Class Libraries (BCL). It implements the [.NET Standard Library](../standard/library.md) specification. .NET Core provides a subset of the APIs that are available in the .NET Framework or Mono/Xamarin. In some cases, types are not fully implemented (some members are not available or have been moved).
 
 Look at the [.NET Core roadmap](https://github.com/dotnet/core/blob/master/roadmap.md) to learn more about the .NET Core API roadmap.
 
-Relationship to the .NET Standard Library
------------------------------------------
+### Relationship to the .NET Standard Library
 
 The [.NET Standard Library](../standard/library.md) is an API spec that describes the consistent set of .NET APIs that developers can expect in each .NET implementation. .NET implementations need to implement this spec in order to be considered .NET Standard Library compliant and to support libraries that target the .NET Standard Library. 
 
 .NET Core implements the .NET Standard Library, and therefore supports .NET Standard Libraries.
 
-Workloads
----------
+### Workloads
 
 By itself, .NET Core includes a single application model -- console apps -- which is useful for tools, local services and text-based games. Additional application models have been built on top of .NET Core to extend its functionality, such as:
 
 - [ASP.NET Core](http://asp.net)
 - [Windows 10 Universal Windows Platform (UWP)](https://developer.microsoft.com/windows)
 - [Xamarin.Forms](https://www.xamarin.com/forms)
 
-Open Source
------------
+### Open Source
 
 [.NET Core](https://github.com/dotnet/core) is open source (MIT license) and was contributed to the [.NET Foundation](http://dotnetfoundation.org) by Microsoft in 2014. It is now one of the most active .NET Foundation projects. It can be freely adopted by individuals and companies, including for personal, academic or commercial purposes. Multiple companies use .NET Core as part of apps, tools, new platforms and hosting services. Some of these companies make significant contributions to .NET Core on GitHub and provide guidance on the product direction as part of the [.NET Foundation Technical Steering Group](http://www.dotnetfoundation.org/blog/tsg-welcome).
 
-Acquisition
-===========
+## Acquisition
 
 .NET Core is distributed in two main ways, as packages on NuGet.org and as standalone distributions.
 
-Distributions
--------------
+### Distributions
 
 You can download .NET Core at the [.NET Core Getting Started](https://www.microsoft.com/net/core) page.
 
@@ -88,19 +79,16 @@ You can download .NET Core at the [.NET Core Getting Started](https://www.micros
 
 Typically, you will first install the .NET Core SDK to get started with .NET Core development. You may choose to install additional .NET Core (perhaps pre-release) builds.
 
-Packages
---------
+### Packages
 
 - [.NET Core Packages](packages.md) contain the .NET Core runtime and libraries (reference assemblies and implementations). For example, [System.Net.Http](https://www.nuget.org/packages/System.Net.Http/).
 - [.NET Core Metapackages](packages.md) describe various layers and app-models by referencing the appropriate set of versioned library packages.
 
-Architecture
-============
+## Architecture
 
 .NET Core is a cross-platform .NET implementation. The primary architectural concerns unique to .NET Core are related to providing platform-specific implementations for supported platforms.
 
-Environments
-------------
+### Environments
 
 .NET Core is supported by Microsoft on Windows, macOS and Linux. On Linux, Microsoft primarily supports .NET Core running on Red Hat Enterprise Linux (RHEL) and Debian distribution families.
 
@@ -110,8 +98,7 @@ The [.NET Core Roadmap](https://github.com/dotnet/core/blob/master/roadmap.md) p
 
 Other companies or groups may support .NET Core for other app types and environment.
 
-Designed for Adaptability
--------------------------
+### Designed for Adaptability
 
 .NET Core has been built as a very similar but unique product relative to other .NET products. It has been designed to enable broad adaptability to new platforms, for new workloads and with new compiler toolchains. It has several OS and CPU ports in progress and may be ported to many more. An example is the [LLILC](https://github.com/dotnet/llilc) project, which is an early prototype of native compilation for .NET Core via the [LLVM](http://llvm.org/) compiler.
 
@@ -132,13 +119,11 @@ There are a mix of platform-specific and platform-neutral libraries in .NET Core
 - [System.IO](https://github.com/dotnet/corefx/tree/master/src/System.IO) and [System.Security.Cryptography.Algorithms](https://github.com/dotnet/corefx/tree/master/src/System.Security.Cryptography.Algorithms) are platform-specific, given that the storage and cryptography APIs differ significantly on each OS. 
 - [System.Collections](https://github.com/dotnet/corefx/tree/master/src/System.Collections) and [System.Linq](https://github.com/dotnet/corefx/tree/master/src/System.Linq) are platform-neutral, given that they create and operate over data structures.
 
-Comparisons to other .NET Platforms
-===================================
+## Comparisons to other .NET Platforms
 
 It is perhaps easiest to understand the size and shape of .NET Core by comparing it to existing .NET platforms. 
 
-Comparison with .NET Framework
-------------------------------
+### Comparison with .NET Framework
 
 The .NET platform was first announced by Microsoft in 2000 and then evolved from there. The .NET Framework has been the primary .NET product produced by Microsoft during that 15+ year span. 
 
@@ -152,8 +137,7 @@ The major differences between .NET Core and the .NET Framework:
 
 While .NET Core is unique and has significant differences to the .NET Framework and other .NET platforms, it is straightforward to share code, using either source or binary sharing techniques. 
 
-Comparison with Mono
---------------------
+### Comparison with Mono
 
 [Mono](http://www.mono-project.com/) is the original cross-platform and [open source](https://github.com/mono/mono) .NET implementation, first shipping in 2004. It can be thought of as a community clone of the .NET Framework. The Mono project team relied on the open [.NET standards](https://github.com/dotnet/coreclr/blob/master/Documentation/project-docs/dotnet-standards.md) (notably ECMA 335) published by Microsoft in order to provide a compatible implementation.
 

docs/core/packages.md

@@ -12,16 +12,14 @@ ms.devlang: dotnet
 ms.assetid: 609b0845-49e7-4864-957b-21ffe1b93bf2
 ---
 
-Packages, Metapackages and Frameworks
-=====================================
+# Packages, Metapackages and Frameworks
 
 .NET Core is a platform made of NuGet packages. Some product experiences benefit from fine-grained definition of packages while others from coarse-grained. To accommodate this duality, the product is distributed as a fine-grained set of packages and then described in courser chunks with a package type informally called a "metapackage".
 
 Each of the .NET Core packages support being run on multiple .NET runtimes, represented as
 frameworks. Some of those frameworks are traditional frameworks, like `net46`, representing the .NET Framework. Another set is new frameworks that can be thought of as "package-based frameworks", which establish a new model for defining frameworks. These package-based frameworks are entirely formed and defined as packages, forming a strong relationship between packages and frameworks.
 
-Packages
-========
+## Packages
 
 .NET Core is split into a set of packages, which provide primitives, higher-level data types, app composition types and common utilities. Each of these packages represent a single assembly of the same name. For example, [System.Runtime](https://www.nuget.org/packages/System.Runtime) contains System.Runtime.dll. 
 
@@ -58,8 +56,7 @@ Packages are referenced in project.json. In the example below, the [System.Runti
 
 In most cases, you will not reference the lower-level .NET Core packages directly since you'll end up with too many packages to manage. Instead, you'll reference a metapackage.
 
-Metapackages
-============
+## Metapackages
 
 Metapackages are a NuGet package convention for describing a set of packages that are meaningful together. They represent this set of packages by making them dependencies. They can optionally establish a
 framework for this set of packages by specifying a framework. 
@@ -110,8 +107,7 @@ In the following example, the `Microsoft.NETCore.App` metapackage is referenced,
 }
 ```
 
-Frameworks
-==========
+## Frameworks
 
 .NET Core packages each support a set of frameworks, declared with framework folders (within the lib and ref folders mentioned earlier). Frameworks describe an available API set (and potentially other characteristics) that you can rely on when you target a given framework. They are versioned as new APIs are added.
 
@@ -127,8 +123,7 @@ The `.NETFramework,Version=4.6` framework represents the available APIs in the .
 
 The `.NETStandard,Version=1.3` framework is a package-based framework. It relies on packages that target the framework to define and expose APIs in terms of the framework.
 
-Package-based Frameworks
-========================
+## Package-based Frameworks
 
 There is a two-way relationship between frameworks and packages. The first part is defining the APIs available for a given framework, for example `netstandard1.3`. Packages that target `netstandard1.3` (or compatible frameworks, like `netstandard1.0') define the APIs available for `netstandard1.3`. That may sound like a circular definition, but it isn't. By virtue of being "package-based", the API definition for the framework comes from packages. The framework itself doesn't define any APIs.
 
@@ -145,8 +140,7 @@ The two primary package-based frameworks used with .NET Core are:
 - `netstandard`
 - `netcoreapp`
 
-.NET Standard
--------------
+### .NET Standard
 
 The .NET Standard (TFM: `netstandard`) framework represents the APIs defined by and built on top of the [.NET Standard Library](../standard/library.md). Libraries that are intended to run on multiple runtimes should target this framework. They will be supported on any .NET Standard compliant runtime, such as .NET Core, .NET Framework and Mono/Xamarin. Each of these runtimes supports a set of .NET Standard versions, depending on which APIs they implement. 
 
@@ -182,8 +176,7 @@ It may seem strange to target `netstandard1.3` but use the 1.5.0 version of `NET
 
 The reverse would not be valid: targeting `netstandard1.5` with the 1.3.0 version of `NETStandard.Library`. You cannot target a higher framework with a lower metapackage, since the lower version metapackage will not expose any assets for that higher framework. The [versioning scheme] for metapackages asserts that metapackages match the highest version of the framework they describe. By virtue of the versioning scheme, the first version of `NETStandard.Library` is v1.5.0 given that it contains `netstandard1.5` assets. v1.3.0 is used in the example above, for symmetry with the example above, but does not actually exist.
 
-.NET Core Application
----------------------
+### .NET Core Application
 
 The .NET Core Application (TFM: `netcoreapp`) framework represents the packages and associated APIs that come with the .NET Core distribution and the console application model that it provides. .NET Core apps must use this framework, due to targeting the console application model, as should libraries that intended to run only on .NET Core. Using this framework restricts apps and libraries to running only on .NET Core. 
 

docs/core/testing/index.md

@@ -22,7 +22,7 @@ briefly introduces unit tests (and how they differ from other kinds of tests).
 Linked resources demonstrates how to add a test project to your solution and
 then run unit tests using either the command line or Visual Studio.
 
-# Getting Started with Testing
+## Getting Started with Testing
 
 Having a suite of automated tests is one of the best ways to ensure a
 software application does what its authors intended it to do. There are

docs/core/testing/unit-testing-with-dotnet-test.md

@@ -18,7 +18,7 @@ By [Steve Smith](http://ardalis.com) and [Bill Wagner](https://github.com/BillWa
 
 [View or download sample code](https://github.com/dotnet/core-docs/tree/master/samples/unit-testing/using-dotnet-test)
 
-# Creating the Projects
+## Creating the Projects
 
 [Writing Libraries with Cross Platform Tools](../tutorials/libraries.md)
 has information on organizing multi-project solutions for both the
@@ -50,7 +50,7 @@ contains the names of your `src` and `test` directories:
 }
 ```
 
-## Creating the source project
+### Creating the source project
 
 Then, in the `src` directory, create the `PrimeService` directory.
 CD into that directory, and run `dotnet new` to create the source
@@ -94,7 +94,7 @@ namespace Prime.Services
 
 ```
 
-## Creating the test project
+### Creating the test project
 
 Next, cd into the 'test' directory, and create the `PrimeServices.Tests` directory.
 CD into the `PrimeServices.Tests` directory and create a new project using `dotnet new`.
@@ -166,7 +166,7 @@ After this initial structure is in place, you can write your first test.
 Once you verify that first unit test, everything is configured and should run smoothly
 as you add features and tests.
 
-# Creating the first test
+## Creating the first test
 
 The TDD approach calls for writing one failing test, then making it pass,
 then repeating the process. So, let's write that one failing test. Remove
@@ -222,7 +222,7 @@ public bool IsPrime(int candidate)
 } 
 ```
 
-## Adding More Features
+### Adding More Features
 
 Now, that you've made one test pass, it's time to write more.
 There are a few other simple cases for prime numbers: 0, -1. You