examples

+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

+Examples for Developers
+=======================
+
+Project site: http://drupal.org/project/examples
+
+Code: https://drupal.org/project/examples/git-instructions
+
+Issues: https://drupal.org/project/issues/examples
+
+What Is This?
+-------------
+
+This set of modules is intended to provide working examples of Drupal 8's
+features and APIs.  The modules strive to be simple, well documented and
+modification friendly, in order to help developers quickly learn their inner
+workings.
+
+These examples are meant to teach you about code-level development for Drupal
+8. Some solutions might be better served using a contributed module, so that
+you don't end up having to re-invent the wheel in PHP.
+
+
+How To Use The Examples
+-----------------------
+
+There are three main ways to interact with the examples in this project:
+
+1. Enable the modules and use them within Drupal. Not all modules will have
+obvious things to see within your Drupal installation. For instance, while the
+Page and Form API examples will display forms, the Database API example does not
+have much that is visible within Drupal.
+
+2. Read the code. Much effort has gone into making the example code readable,
+not only in terms of the code itself, but also the extensive inline comments
+and documentation blocks.
+
+3. Browse the code and documentation on the web. There are two main places to
+do this:
+
+* https://api.drupal.org/api/examples is the main API site for all of Drupal.
+It has all manner of cross-linked references between the example code and the
+APIs being demonstrated. All of the Doxygen-based comments in the code are
+parsed and made browseable here.
+
+* http://drupalcode.org/project/examples.git allows you to browse the git
+repository for the Examples project.
+
+Note also that in the future, many modules from the Examples project will be
+moved into Drupal 8 core. This means some examples will come with Drupal
+itself. As of this writing, none have been migrated to Drupal 8 yet.
+
+This collection of modules ship with a composer.json file outlining the name,
+description, type and license of the package. Although not used by Drupal itself
+it allows the module to be installed via composer, therfore all contrib modules
+should ship with one.
+
+How To Install The Modules
+--------------------------
+
+1. The Examples project installs like any other Drupal module. There is extensive
+documentation on how to do this here: https://drupal.org/documentation/install/modules-themes/modules-8
+
+2. Enable any Example sub-module you wish to explore in Admin menu > Extend.
+
+3. Rebuild access permissions if you are prompted to.
+
+4. Profit!  The links for Examples material will appear in your Tools menu. This
+menu appears on the left sidebar by default. You'll need to reenable it if you
+removed it.
+
+Having seen the behavior of the various example modules, you can move on to
+reading the code, experimenting with it, and hopefully grasp how things work.
+
+If you find a problem, incorrect comment, obsolete or improper code or such,
+please search for an issue about it at http://drupal.org/project/issues/examples
+If there isn't already an issue for it, please create a new one.
+
+Thanks.
+

+name: Block Example
+type: module
+description: An example outlining how a module can define blocks.
+package: Example modules
+# core: 8.x
+dependencies:
+  - block
+  - examples
+
+# Information added by Drupal.org packaging script on 2015-11-11
+version: '8.x-1.x-dev'
+core: '8.x'
+project: 'examples'
+datestamp: 1447204146

+block_example.description:
+  title: Block Example
+  route_name: block_example.description

+<?php
+
+/**
+ * @file
+ * Module file for block_example.
+ */
+
+use Drupal\Component\Utility\Unicode;
+use Drupal\Core\Block\BlockPluginInterface;
+
+/**
+ * @defgroup block_example Example: Block
+ * @ingroup examples
+ * @{
+ * Demonstrates code creation of blocks.
+ *
+ * This is an example outlining how a module can define blocks that can be
+ * displayed on various pages of a site, or how to alter blocks provided by
+ * other modules.
+ */
+
+/**
+ * Implements hook_block_view_alter().
+ *
+ * This hook allows you to modify the output of any block in the system.
+ *
+ * In addition, instead of hook_block_view_alter(), which is called for all
+ * blocks, you can also use hook_block_view_MODULE_DELTA_alter() to alter a
+ * specific block. To change only our block using
+ * hook_block_view_MODULE_DELTA_alter, we would use the function:
+ * block_example_block_view_block_example_example_configurable_text_alter()
+ *
+ * We are going to uppercase the subject (the title of the block as shown to the
+ * user) of any block if the string "uppercase" appears in the block title or
+ * subject. Default block titles are set programmatically in the subject key;
+ * titles created through the UI are saved in the title key. This module creates
+ * an example block to demonstrate this effect (default title set
+ * programmatically as subject).  You can also demonstrate the effect of this
+ * hook by creating a new block whose title has the string 'uppercase' in it
+ * (set as title through the UI).
+ */
+function block_example_block_view_alter(array &$build, BlockPluginInterface $block) {
+  // We'll search for the string 'uppercase'.
+  $definition = $block->getPluginDefinition();
+  if ((!empty($build['#configuration']['label']) && stristr($build['#configuration']['label'], 'uppercase')) || (!empty($definition['subject']) && stristr($definition['subject'], 'uppercase'))) {
+    // This will uppercase the block title.
+    $build['#configuration']['label'] = Unicode::strtoupper($build['#configuration']['label']);
+  }
+}
+
+/**
+ * @} End of "defgroup block_example".
+ */

+block_example.description:
+  path: '/examples/block_example'
+  defaults:
+    _controller: '\Drupal\block_example\Controller\BlockExampleController::description'
+    _title: 'Block Example'
+  requirements:
+    _permission: 'access content'

+block.settings.example_configurable_text:
+  type: block_settings
+  label: 'Example configurable text block configuration'
+  mapping:
+    block_example_string:
+      type: text
+      label: 'Block contents'

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\block_example\Controller\BlockExampleController.
+ */
+
+namespace Drupal\block_example\Controller;
+
+use Drupal\Core\Controller\ControllerBase;
+use Drupal\Core\Url;
+
+/**
+ * Controller routines for block example routes.
+ */
+class BlockExampleController extends ControllerBase {
+
+  /**
+   * A simple controller method to explain what the block example is about.
+   */
+  public function description() {
+    // Make a link from a route to the block admin page.
+    $url = Url::fromRoute('block.admin_display');
+    $block_admin_link = $this->l($this->t('the block admin page'), $url);
+
+    // Put the link into the content.
+    $build = array(
+      '#markup' => $this->t('The Block Example provides three sample blocks which demonstrate the various block APIs. To experiment with the blocks, enable and configure them on @block_admin_link.', ['@block_admin_link' => $block_admin_link]),
+    );
+
+    return $build;
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\block_example\Plugin\Block\ExampleConfigurableTextBlock.
+ */
+
+namespace Drupal\block_example\Plugin\Block;
+
+use Drupal\Core\Block\BlockBase;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Provides a 'Example: configurable text string' block.
+ *
+ * Drupal\Core\Block\BlockBase gives us a very useful set of basic functionality
+ * for this configurable block. We can just fill in a few of the blanks with
+ * defaultConfiguration(), blockForm(), blockSubmit(), and build().
+ *
+ * @Block(
+ *   id = "example_configurable_text",
+ *   admin_label = @Translation("Title of first block (example_configurable_text)")
+ * )
+ */
+class ExampleConfigurableTextBlock extends BlockBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function defaultConfiguration() {
+    return array(
+      'block_example_string' => $this->t('A default value. This block was created at %time', array('%time' => date('c'))),
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function blockForm($form, FormStateInterface $form_state) {
+    $form['block_example_string_text'] = array(
+      '#type' => 'textarea',
+      '#title' => $this->t('Block contents'),
+      '#description' => $this->t('This text will appear in the example block.'),
+      '#default_value' => $this->configuration['block_example_string'],
+    );
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function blockSubmit($form, FormStateInterface $form_state) {
+    $this->configuration['block_example_string']
+      = $form_state->getValue('block_example_string_text');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function build() {
+    return array(
+      '#type' => 'markup',
+      '#markup' => $this->configuration['block_example_string'],
+    );
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\block_example\Plugin\Block\ExampleEmptyBlock.
+ */
+
+namespace Drupal\block_example\Plugin\Block;
+
+use Drupal\Core\Block\BlockBase;
+
+/**
+ * Provides a 'Example: empty block' block.
+ *
+ * @Block(
+ *   id = "example_empty",
+ *   admin_label = @Translation("Example: empty block")
+ * )
+ */
+class ExampleEmptyBlock extends BlockBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function build() {
+    // We return an empty array on purpose. The block will thus not be rendered
+    // on the site. See BlockExampleTest::testBlockExampleBasic().
+    return array();
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\block_example\Plugin\Block\ExampleUppercaseBlock.
+ */
+
+namespace Drupal\block_example\Plugin\Block;
+
+use Drupal\Core\Block\BlockBase;
+
+/**
+ * Provides a 'Example: uppercase this please' block.
+ *
+ * @Block(
+ *   id = "example_uppercase",
+ *   admin_label = @Translation("Example: uppercase this please")
+ * )
+ */
+class ExampleUppercaseBlock extends BlockBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function build() {
+    return array(
+      '#type' => 'markup',
+      '#markup' => $this->t("This block's title will be changed to uppercase. Any other block with 'uppercase' in the subject or title will also be altered. If you change this block's title through the UI to omit the word 'uppercase', it will still be altered to uppercase as the subject key has not been changed."),
+    );
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\block_example\Tests\BlockExampleMenuTest.
+ */
+
+namespace Drupal\block_example\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Test the user-facing menus in Block Example.
+ *
+ * @ingroup block_example
+ * @group block_example
+ * @group examples
+ */
+class BlockExampleMenuTest extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('block', 'block_example');
+
+  /**
+   * The installation profile to use with this test.
+   *
+   * This test class requires the "Tools" block.
+   *
+   * @var string
+   */
+  protected $profile = 'minimal';
+
+  /**
+   * Test for a link to the block example in the Tools menu.
+   */
+  public function testBlockExampleLink() {
+    $this->drupalGet('');
+    $this->assertLinkByHref('examples/block_example');
+  }
+
+  /**
+   * Tests block_example menus.
+   */
+  public function testBlockExampleMenu() {
+    $this->drupalGet('examples/block_example');
+    $this->assertResponse(200, 'Description page exists.');
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\block_example\Tests\BlockExampleTest.
+ */
+
+namespace Drupal\block_example\Tests;
+
+use Drupal\Component\Utility\Unicode;
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Test the configuration options and block created by Block Example module.
+ *
+ * @ingroup block_example
+ * @group block_example
+ * @group examples
+ */
+class BlockExampleTest extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('block', 'block_example');
+
+  /**
+   * Tests block_example functionality.
+   */
+  public function testBlockExampleBasic() {
+    // Create user.
+    $web_user = $this->drupalCreateUser(array('administer blocks'));
+    // Login the admin user.
+    $this->drupalLogin($web_user);
+
+    $theme_name = \Drupal::config('system.theme')->get('default');
+
+    // Verify the blocks are listed to be added.
+    $this->drupalGet('/admin/structure/block/library/' . $theme_name, ['query' => ['region' => 'content']]);
+    $this->assertRaw(t('Title of first block (example_configurable_text)'), 'Block configurable-string found.');
+    $this->assertRaw(t('Example: empty block'), 'Block empty-block found.');
+    $this->assertRaw(t('Example: uppercase this please'), 'Block uppercase found.');
+
+    // Define and place blocks.
+    $settings_configurable = array(
+      'label' => t('Title of first block (example_configurable_text)'),
+      'id' => 'block_example_example_configurable_text',
+      'theme' => $theme_name,
+    );
+    $this->drupalPlaceBlock('example_configurable_text', $settings_configurable);
+
+    $settings_uppercase = array(
+      'label' => t('Configurable block to be uppercased'),
+      'id' => 'block_example_example_uppercased',
+      'theme' => $theme_name,
+    );
+    $this->drupalPlaceBlock('example_uppercase', $settings_uppercase);
+
+    $settings_empty = array(
+      'label' => t('Example: empty block'),
+      'id' => 'block_example_example_empty',
+      'theme' => $theme_name,
+    );
+    $this->drupalPlaceBlock('example_empty', $settings_empty);
+
+    // Verify that blocks are there. Empty block will not be shown, because it
+    // holds an empty array.
+    $this->drupalGet('');
+    $this->assertRaw($settings_configurable['label'], 'Block configurable test not found.');
+    $this->assertNoRaw($settings_uppercase['label'], 'Block uppercase with normal label not found.');
+    $this->assertRaw(Unicode::strtoupper($settings_uppercase['label']), 'Block uppercase with uppercased label found.');
+    $this->assertNoRaw($settings_empty['label'], 'Block empty not found.');
+
+    // Change content of configurable text block.
+    $edit = array(
+      'settings[block_example_string_text]' => $this->randomMachineName(),
+    );
+    $this->drupalPostForm('/admin/structure/block/manage/' . $settings_configurable['id'], $edit, t('Save block'));
+
+    // Verify that new content is shown.
+    $this->drupalGet('');
+    $this->assertRaw($edit['settings[block_example_string_text]'], 'Content of configurable text block successfully verified.');
+  }
+
+}

+name: Cache example
+description: 'An example outlining how to use Cache API.'
+package: Example modules
+# core: 8.x
+type: module
+dependencies:
+  - examples
+
+# Information added by Drupal.org packaging script on 2015-11-11
+version: '8.x-1.x-dev'
+core: '8.x'
+project: 'examples'
+datestamp: 1447204146

+cache_example.description:
+  title: Cache example
+  description: 'Example of Drupal Cache API'
+  route_name: cache_example.description

+<?php
+
+/**
+ * @file
+ * Outlines how a module can use the Cache API.
+ *
+ * @todo: Demonstrate allowing invalid cache items.
+ * @todo: Demonstrate deleteing cache entries.
+ * @todo: Demonstrate deleteing cache tags.
+ * @todo: Demonstrate deleteing all cache items.
+ * @todo: Demonstrate invalidating cache entries.
+ * @todo: Demonstrate invalidating cache tags.
+ * @todo: Demonstrate invalidating all cache items.
+ */
+
+/**
+ * @defgroup cache_example Example: Cache API
+ * @ingroup examples
+ * @{
+ * Outlines how a module can use the Cache API.
+ *
+ * Cache API allows us to cache data that is heavy to calculate. As this can
+ * significantly speed up the Drupal site, it is recommended to use cache
+ * mechanism when it is appropriate.
+ *
+ * Cache in Drupal is very easy to use. This example will search entire Drupal
+ * folder and display all files. Since this operation includes filesystem it can
+ * take a while. This list will not change much on production
+ * websites, so we decide to cache it.
+ *
+ * @see \Drupal\Core\Cache\CacheBackendInterface
+ */
+
+/**
+ * @} End of "defgroup cache_example".
+ */

+cache_example.description:
+  path: 'examples/cache_example'
+  defaults:
+    _form: '\Drupal\cache_example\Forms\CacheExampleForm'
+  requirements:
+    _permission: 'access content'

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\cron_example\Form\CronExampleForm.
+ */
+
+namespace Drupal\cache_example\Forms;
+
+use Drupal\Core\Form\FormBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Session\AccountProxyInterface;
+use Drupal\Core\StringTranslation\TranslationInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\HttpFoundation\RequestStack;
+
+
+/**
+ * Form with examples on how to use cache.
+ */
+class CacheExampleForm extends FormBase {
+
+  /**
+   * The current user.
+   *
+   * @var \Drupal\Core\Session\AccountProxyInterface
+   */
+  protected $currentUser;
+
+  /**
+   * The cache.default cache backend.
+   *
+   * @var \Drupal\Core\Cache\CacheBackendInterface
+   */
+  protected $cacheBackend;
+
+  /**
+   * Dependency injection through the constructor.
+   *
+   * @param \Symfony\Component\HttpFoundation\RequestStack $request_stack
+   *   The request stack service.
+   * @param \Drupal\Core\StringTranslation\TranslationInterface $translation
+   *   The string translation service.
+   * @param \Drupal\Core\Session\AccountProxyInterface $current_user
+   *   The current active user service.
+   * @param \Drupal\Core\Cache\CacheBackendInterface $cache_backend
+   *   The cache object associated with the default bin.
+   */
+  public function __construct(
+    RequestStack $request_stack,
+    TranslationInterface $translation,
+    AccountProxyInterface $current_user,
+    CacheBackendInterface $cache_backend
+  ) {
+    $this->setRequestStack($request_stack);
+    $this->setStringTranslation($translation);
+    $this->currentUser = $current_user;
+    $this->cacheBackend = $cache_backend;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container) {
+    // Forms that require a Drupal service or a custom service should access
+    // the service using dependency injection.
+    // @link https://www.drupal.org/node/2203931.
+    // Those services are passed in the $container through the static create
+    // method.
+    return new static(
+      $container->get('request_stack'),
+      $container->get('string_translation'),
+      $container->get('current_user'),
+      $container->get('cache.default')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId() {
+    return 'cron_cache';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    // Log execution time.
+    $start_time = microtime(TRUE);
+
+    // Try to load the files count from cache. This function will accept two
+    // arguments:
+    // - cache object name (cid)
+    // - cache bin, the (optional) cache bin (most often a database table) where
+    //   the object is to be saved.
+    //
+    // cache_get() returns the cached object or FALSE if object does not exist.
+    if ($cache = $this->cacheBackend->get('cache_example_files_count')) {
+      /*
+       * Get cached data. Complex data types will be unserialized automatically.
+       */
+      $files_count = $cache->data;
+    }
+    else {
+      // If there was no cached data available we have to search filesystem.
+      // Recursively get all .PHP files from Drupal's core folder.
+      $files_count = count(file_scan_directory('core', '/.php/'));
+
+      // Since we have recalculated, we now need to store the new data into
+      // cache. Complex data types will be automatically serialized before
+      // being saved into cache.
+      // Here we use the default setting and create an unexpiring cache item.
+      // See below for an example that creates an expiring cache item.
+      $this->cacheBackend->set('cache_example_files_count', $files_count, CacheBackendInterface::CACHE_PERMANENT);
+    }
+
+    $end_time = microtime(TRUE);
+    $duration = $end_time - $start_time;
+
+    // Format intro message.
+    $intro_message = '<p>' . $this->t("This example will search Drupal's core folder and display a count of the PHP files in it.") . ' ';
+    $intro_message .= $this->t('This can take a while, since there are a lot of files to be searched.') . ' ';
+    $intro_message .= $this->t('We will search filesystem just once and save output to the cache. We will use cached data for later requests.') . '</p>';
+    $intro_message .= '<p>'
+      . $this->t(
+        '<a href="@url">Reload this page</a> to see cache in action.',
+        array('@url' => $this->getRequest()->getRequestUri())
+      )
+      . ' ';
+    $intro_message .= $this->t('You can use the button below to remove cached data.') . '</p>';
+
+    $form['file_search'] = array(
+      '#type' => 'fieldset',
+      '#title' => $this->t('File search caching'),
+    );
+    $form['file_search']['introduction'] = array(
+      '#markup' => $intro_message,
+    );
+
+    $color = empty($cache) ? 'red' : 'green';
+    $retrieval = empty($cache) ? $this->t('calculated by traversing the filesystem') : $this->t('retrieved from cache');
+
+    $form['file_search']['statistics'] = array(
+      '#type' => 'item',
+      '#markup' => $this->t('%count files exist in this Drupal installation; @retrieval in @time ms. <br/>(Source: <span style="color:@color;">@source</span>)', array(
+        '%count' => $files_count,
+        '@retrieval' => $retrieval,
+        '@time' => number_format($duration * 1000, 2),
+        '@color' => $color,
+        '@source' => empty($cache) ? $this->t('actual file search') : $this->t('cached'),
+        )
+      ),
+    );
+    $form['file_search']['remove_file_count'] = array(
+      '#type' => 'submit',
+      '#submit' => array(array($this, 'expireFiles')),
+      '#value' => $this->t('Explicitly remove cached file count'),
+    );
+
+    $form['expiration_demo'] = array(
+      '#type' => 'fieldset',
+      '#title' => $this->t('Cache expiration settings'),
+    );
+    $form['expiration_demo']['explanation'] = array(
+      '#markup' => $this->t('A cache item can be set as CACHE_PERMANENT, meaning that it will only be removed when explicitly cleared, or it can have an expiration time (a Unix timestamp).'),
+    );
+
+    $item = $this->cacheBackend->get('cache_example_expiring_item', TRUE);
+    if ($item == FALSE) {
+      $item_status = $this->t('Cache item does not exist');
+    }
+    else {
+      $item_status = $item->valid ? $this->t('Cache item exists and is set to expire at %time', array('%time' => $item->data)) :
+      $this->t('Cache_item is invalid');
+    }
+
+    $form['expiration_demo']['current_status'] = array(
+      '#type' => 'item',
+      '#title' => $this->t('Current status of cache item "cache_example_expiring_item"'),
+      '#markup' => $item_status,
+    );
+    $form['expiration_demo']['expiration'] = array(
+      '#type' => 'select',
+      '#title' => $this->t('Time before cache expiration'),
+      '#options' => array(
+        'never_remove' => $this->t('CACHE_PERMANENT'),
+        -10 => $this->t('Immediate expiration'),
+        10 => $this->t('10 seconds from form submission'),
+        60 => $this->t('1 minute from form submission'),
+        300 => $this->t('5 minutes from form submission'),
+      ),
+      '#default_value' => -10,
+      '#description' => $this->t('Any cache item can be set to only expire when explicitly cleared, or to expire at a given time.'),
+    );
+    $form['expiration_demo']['create_cache_item'] = array(
+      '#type' => 'submit',
+      '#value' => $this->t('Create a cache item with this expiration'),
+      '#submit' => array(array($this, 'createExpiringItem')),
+    );
+
+    $form['cache_clearing'] = array(
+      '#type' => 'fieldset',
+      '#title' => $this->t('Expire and remove options'),
+      '#description' => $this->t("We have APIs to expire cached items and also to just remove them. Unfortunately, they're all the same API, cache_clear_all"),
+    );
+    $form['cache_clearing']['cache_clear_type'] = array(
+      '#type' => 'radios',
+      '#title' => $this->t('Type of cache clearing to do'),
+      '#options' => array(
+        'expire' => $this->t('Remove items from the "cache" bin that have expired'),
+        'remove_all' => $this->t('Remove all items from the "cache" bin regardless of expiration'),
+        'remove_tag' => $this->t('Remove all items in the "cache" bin with the tag "cache_example" set to 1'),
+      ),
+      '#default_value' => 'expire',
+    );
+    // Submit button to clear cached data.
+    $form['cache_clearing']['clear_expired'] = array(
+      '#type' => 'submit',
+      '#value' => $this->t('Clear or expire cache'),
+      '#submit' => array(array($this, 'cacheClearing')),
+      '#access' => $this->currentUser->hasPermission('administer site configuration'),
+    );
+
+    return $form;
+  }
+
+  /**
+   * Submit handler that explicitly clears cache_example_files_count from cache.
+   */
+  public function expireFiles($form, &$form_state) {
+    // Clear cached data. This function will delete cached object from cache
+    // bin.
+    //
+    // The first argument is cache id to be deleted. Since we've provided it
+    // explicitly, it will be removed whether or not it has an associated
+    // expiration time. The second argument (required here) is the cache bin.
+    // Using cache_clear_all() explicitly in this way
+    // forces removal of the cached item.
+    $this->cacheBackend->delete('cache_example_files_count');
+
+    // Display message to the user.
+    drupal_set_message($this->t('Cached data key "cache_example_files_count" was cleared.'), 'status');
+  }
+
+  /**
+   * Submit handler to create a new cache item with specified expiration.
+   */
+  public function createExpiringItem($form, &$form_state) {
+
+    $tags = array(
+      'cache_example:1',
+    );
+
+    $interval = $form_state->getValue('expiration');
+    if ($interval == 'never_remove') {
+      $expiration = CacheBackendInterface::CACHE_PERMANENT;
+      $expiration_friendly = $this->t('Never expires');
+    }
+    else {
+      $expiration = time() + $interval;
+      $expiration_friendly = format_date($expiration);
+    }
+    // Set the expiration to the actual Unix timestamp of the end of the
+    // required interval. Also add a tag to it to be able to clear caches more
+    // precise.
+    $this->cacheBackend->set('cache_example_expiring_item', $expiration_friendly, $expiration, $tags);
+    drupal_set_message($this->t('cache_example_expiring_item was set to expire at %time', array('%time' => $expiration_friendly)));
+  }
+
+  /**
+   * Submit handler to demonstrate the various uses of cache_clear_all().
+   */
+  public function cacheClearing($form, &$form_state) {
+    switch ($form_state->getValue('cache_clear_type')) {
+      case 'expire':
+        // Here we'll remove all cache keys in the 'cache' bin that have
+        // expired.
+        $this->cacheBackend->garbageCollection();
+        drupal_set_message($this->t('\Drupal::cache()->garbageCollection() was called, removing any expired cache items.'));
+        break;
+
+      case 'remove_all':
+        // This removes all keys in a bin using a super-wildcard. This
+        // has nothing to do with expiration. It's just brute-force removal.
+        $this->cacheBackend->deleteAll();
+        drupal_set_message($this->t('ALL entries in the "cache" bin were removed with \Drupal::cache()->deleteAll().'));
+        break;
+
+      case 'remove_tag':
+        // This removes cache entries with the tag "cache_example" set to 1 in
+        // the "cache".
+        $tags = array(
+          'cache_example:1',
+        );
+        Cache::invalidateTags($tags);
+        drupal_set_message($this->t('Cache entries with the tag "cache_example" set to 1 in the "cache" bin were invalidated with \Drupal\Core\Cache\Cache::invalidateTags($tags).'));
+        break;
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Test case for testing the cache example module.
+ */
+
+namespace Drupal\cache_example\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Tests for the cache_example module.
+ *
+ * @ingroup cache_example
+ * @group cache_example
+ * @group examples
+ */
+class CacheExampleTestCase extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('cache_example');
+
+  /**
+   * The installation profile to use with this test.
+   *
+   * @var string
+   */
+  protected $profile = 'minimal';
+
+  /**
+   * Test menu links and routes.
+   *
+   * Test the following:
+   * - A link to the cache_example in the Tools menu.
+   * - That you can successfully access the cache_example form.
+   */
+  public function testCacheExampleMenu() {
+
+    // Test for a link to the cache_example in the Tools menu.
+    $this->drupalGet('');
+    $this->assertResponse(200, 'The Home page is available.');
+    $this->assertLinkByHref('examples/cache_example');
+
+    // Verify if the can successfully access the cache_example form.
+    $this->drupalGet('examples/cache_example');
+    $this->assertResponse(200, 'The Cache Example description page is available.');
+  }
+
+  /**
+   * Test that our caches function.
+   *
+   * Does the following:
+   * - Load cache example page and test if displaying uncached version.
+   * - Reload once again and test if displaying cached version.
+   * - Find reload link and click on it.
+   * - Clear cache at the end and test if displaying uncached version again.
+   */
+  public function testCacheExampleBasic() {
+
+    // We need administrative privileges to clear the cache.
+    $admin_user = $this->drupalCreateUser(array('administer site configuration'));
+    $this->drupalLogin($admin_user);
+
+    // Get initial page cache example page, first time accessed,
+    // and assert uncached output.
+    $this->drupalGet('examples/cache_example');
+    $this->assertText('Source: actual file search');
+
+    // Reload the page; the number should be cached.
+    $this->drupalGet('examples/cache_example');
+    $this->assertText('Source: cached');
+
+    // Now push the button to remove the count.
+    $this->drupalPostForm('examples/cache_example', array(), t('Explicitly remove cached file count'));
+    $this->assertText('Source: actual file search');
+
+    // Create a cached item. First make sure it doesn't already exist.
+    $this->assertText('Cache item does not exist');
+    $this->drupalPostForm('examples/cache_example', array('expiration' => -10), t('Create a cache item with this expiration'));
+    // We should now have an already-expired item. Automatically invalid.
+    $this->assertText('Cache_item is invalid');
+    // Now do the expiration operation.
+    $this->drupalPostForm('examples/cache_example', array('cache_clear_type' => 'expire'), t('Clear or expire cache'));
+    // And verify that it was removed.
+    $this->assertText('Cache item does not exist');
+
+    // Create a cached item. This time we'll make it not expire.
+    $this->drupalPostForm('examples/cache_example', array('expiration' => 'never_remove'), t('Create a cache item with this expiration'));
+    // We should now have an never-remove item.
+    $this->assertText('Cache item exists and is set to expire at Never expires');
+    // Now do the expiration operation.
+    $this->drupalPostForm('examples/cache_example', array('cache_clear_type' => 'expire'), t('Clear or expire cache'));
+    // And verify that it was not removed.
+    $this->assertText('Cache item exists and is set to expire at Never expires');
+    // Now do tag invalidation.
+    $this->drupalPostForm('examples/cache_example', array('cache_clear_type' => 'remove_tag'), t('Clear or expire cache'));
+    // And verify that it was invalidated.
+    $this->assertText('Cache_item is invalid');
+    // Do the hard delete
+    $this->drupalPostForm('examples/cache_example', array('cache_clear_type' => 'remove_all'), t('Clear or expire cache'));
+    // And verify that it was removed.
+    $this->assertText('Cache item does not exist');
+  }
+
+}

+{
+    "name": "drupal/examples",
+    "description": "The Examples for Developers project aims to provide high-quality, well-documented API examples for a broad range of Drupal core functionality.",
+    "type": "drupal-module",
+    "license": "GPL-2.0+"
+}

+# This file defines a default config entity. This allows the module to include
+# config entities that are present 'out of the box'. Default config entities
+# are created in Drupal when the module is enabled. They are removed when the
+# module is uninstalled.
+
+# Default config entities can be edited by the user within Drupal. This edited
+# entity wil become exportable through the configuration system. This file,
+# however, will remain untouched.
+
+# For our config entity to be added at installation time, we have to place it in
+# the config/install directory of our module. Thus our file is located at:
+# config/install/config_entity_example.robot.marvin.yml.
+
+# You can see where these properties are defined in the annotation of
+# Drupal\config_entity_example\Entity\Robot.
+
+# The id of the config entity.
+id: marvin
+# Our properties follow.
+label: 'Marvin, the paranoid android'

+# Schema for the configuration files of the Config Entity Example module.
+
+# This schema tells the config system how to read our config YML files.
+# See for example the file config/config_entity_example.robot.marvin.yml, which
+# contains our default config entity.
+
+# Documentation for schema files like this one is located here:
+# https://drupal.org/node/1905070
+
+config_entity_example.robot.*:
+  type: mapping
+  label: 'Robot'
+  mapping:
+    id:
+      type: string
+      label: 'Robot id'
+    uuid:
+      type: string
+      label: 'UUID'
+    label:
+      type: label
+      label: 'Label'
+    floopy:
+      type: boolean
+      label: 'Floopy'
+    langcode:
+      type: string
+      label: 'Default language'

+name: 'Config entity example'
+type: module
+description: 'An example module showing how to create a config entity type.'
+package: Example modules
+# core: 8.x
+dependencies:
+  - examples
+
+# Information added by Drupal.org packaging script on 2015-11-11
+version: '8.x-1.x-dev'
+core: '8.x'
+project: 'examples'
+datestamp: 1447204146

+# Add some local task links to facilitate navigation.
+
+config_entity_example.add_action:
+  route_name: entity.robot.add_form
+  title: 'Add robot'
+  appears_on:
+    - entity.robot.list
+
+config_entity_example.list_action:
+  route_name: entity.robot.list
+  title: 'List Robots'
+  appears_on:
+    - entity.robot.add_form
+    - entity.robot.edit
+    - entity.robot.delete

+config_entity_example.menu:
+  title: Config Entity Example
+  route_name: entity.robot.list

+<?php
+
+/**
+ * @file
+ * Demonstrates how to define a new configuration entity type.
+ */
+
+/**
+ * @defgroup config_entity_example Example: Config Entity
+ * @ingroup examples
+ * @{
+ * Implement a Config Entity.
+ *
+ * This module demonstrates implementing a Config Entity.
+ *
+ * This is an example of a simple configuration entity, the kind you might
+ * create to store administrator-defined objects like blocks or views.
+ *
+ * In this module we define a configuration entity named 'Robot'. The entity
+ * has a unique ID (also called a machine name), a human-readable label used
+ * for display, and a universally unique identifier. You can create new robots
+ * by navigating to &lt;your_site_root&gt;/examples/config_entity_example. A
+ * default robot, "marvin", is included with the module.
+ *
+ * What's special about a Configuration Entity?
+ *
+ * Configuration entities are entities just like content entities. The key
+ * difference is where the data is stored. Content entities are stored in the
+ * database. Configuration entities are stored in *.yml files, typically under
+ * &lt;your_site_root&gt;/sites/default/files/config_&lt;unique_id&gt;.
+ *
+ * Another key difference with configuration entities is the expectation they
+ * are created by administrators, and not end users. As files, configuration
+ * entities can be added to a version control system.
+ */
+
+/**
+ * @} End of "defgroup config_entity_example".
+ */

+#Define the administer permission for the robot config entity.
+'administer robots':
+  title: 'Administer robots'
+  description: Create and edit robots.

+# The routing.yml file defines the paths for our module.
+# Here we define the paths for our entity type's admin UI.
+
+# This is the router item for listing all entities.
+entity.robot.list:
+  path: '/examples/config_entity_example'
+  defaults:
+    # '_entity_list' tells Drupal to use an entity list controller.
+    # We give the entity ID here. Drupal then looks in the entity's annotation
+    # and looks for the "list" entry under "controllers" for the class to load.
+    # @see \Drupal\Core\Entity\Enhancer\EntityRouteEnhancer
+    _entity_list: 'robot'
+    _title: 'Config Entity Example'
+  requirements:
+    _permission: 'administer robots'
+
+# This is the router item for adding our entity.
+entity.robot.add_form:
+  path: '/examples/config_entity_example/add'
+  defaults:
+    _title: 'Add robot'
+    # Like _entity_list above, _entity_form gives the entity type ID, only this
+    # time also lists the form separated by a period. Drupal looks in the
+    # annotation for the entity and locates the "add" entry under "form" for
+    # the form class to load.
+    # @see \Drupal\Core\Entity\Enhancer\EntityRouteEnhancer
+    _entity_form: robot.add
+  requirements:
+    _entity_create_access: robot
+
+# This is the router item for editing our entity.
+entity.robot.edit_form:
+  # Parameters may be passed to the form via the URL path. We name the
+  # parameter in the path by enclosing it in curly braces. For entity forms,
+  # we include the entity ID in the path by including a parameter with the
+  # same name as the entity type ID.
+  path: '/examples/config_entity_example/manage/{robot}'
+  defaults:
+    _title: 'Edit robot'
+    # List our add entry above, this _entity_form entry instructs Drupal to
+    # read our entity type's annonation, and look for the "edit" entry under
+    # "form".
+    _entity_form: robot.edit
+  requirements:
+    # This uses our entity access controller.
+    # @see \Drupal\Core\Entity\EntityAccessCheck
+    _entity_access: robot.update
+
+# This is the router item for deleting an instance of our entity.
+entity.robot.delete_form:
+  path: '/examples/config_entity_example/manage/{robot}/delete'
+  defaults:
+    _title: 'Delete robot'
+    _entity_form: robot.delete
+  requirements:
+    _entity_access: robot.delete

+<?php
+/**
+ * @file
+ * Contains Drupal\config_entity_example\Controller\RobotListBuilder.
+ */
+
+namespace Drupal\config_entity_example\Controller;
+
+use Drupal\Core\Config\Entity\ConfigEntityListBuilder;
+use Drupal\Core\Entity\EntityInterface;
+
+/**
+ * Provides a listing of robot entities.
+ *
+ * List Controllers provide a list of entities in a tabular form. The base
+ * class provides most of the rendering logic for us. The key functions
+ * we need to override are buildHeader() and buildRow(). These control what
+ * columns are displayed in the table, and how each row is displayed
+ * respectively.
+ *
+ * Drupal locates the list controller by looking for the "list" entry under
+ * "controllers" in our entity type's annotation. We define the path on which
+ * the list may be accessed in our module's *.routing.yml file. The key entry
+ * to look for is "_entity_list". In *.routing.yml, "_entity_list" specifies
+ * an entity type ID. When a user navigates to the URL for that router item,
+ * Drupal loads the annotation for that entity type. It looks for the "list"
+ * entry under "controllers" for the class to load.
+ *
+ * @package Drupal\config_entity_example\Controller
+ *
+ * @ingroup config_entity_example
+ */
+class RobotListBuilder extends ConfigEntityListBuilder {
+
+  /**
+   * Builds the header row for the entity listing.
+   *
+   * @return array
+   *   A render array structure of header strings.
+   *
+   * @see Drupal\Core\Entity\EntityListController::render()
+   */
+  public function buildHeader() {
+    $header['label'] = $this->t('Robot');
+    $header['machine_name'] = $this->t('Machine Name');
+    $header['floopy'] = $this->t('Floopy');
+    return $header + parent::buildHeader();
+  }
+
+  /**
+   * Builds a row for an entity in the entity listing.
+   *
+   * @param EntityInterface $entity
+   *   The entity for which to build the row.
+   *
+   * @return array
+   *   A render array of the table row for displaying the entity.
+   *
+   * @see Drupal\Core\Entity\EntityListController::render()
+   */
+  public function buildRow(EntityInterface $entity) {
+    $row['label'] = $entity->label();
+    $row['machine_name'] = $entity->id();
+    $row['floopy'] = $entity->floopy;
+
+    return $row + parent::buildRow($entity);
+  }
+
+  /**
+   * Adds some descriptive text to our entity list.
+   *
+   * Typically, there's no need to override render(). You may wish to do so,
+   * however, if you want to add markup before or after the table.
+   *
+   * @return array
+   *   Renderable array.
+   */
+  public function render() {
+    $build['description'] = array(
+      '#markup' => $this->t("<p>The Config Entity Example module defines a"
+        . " Robot entity type. This is a list of the Robot entities currently"
+        . " in your Drupal site.</p><p>By default, when you enable this"
+        . " module, one entity is created from configuration. This is why we"
+        . " call them Config Entities. Marvin, the paranoid android, is created"
+        . " in the database when the module is enabled.</p><p>You can view a"
+        . " list of Robots here. You can also use the 'Operations' column to"
+        . " edit and delete Robots.</p>"),
+    );
+    $build[] = parent::render();
+    return $build;
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains Drupal\config_entity_example\Entity\Robot.
+ *
+ * This contains our entity class.
+ *
+ * Originally based on code from blog post at
+ * http://previousnext.com.au/blog/understanding-drupal-8s-config-entities
+ */
+
+namespace Drupal\config_entity_example\Entity;
+
+use Drupal\Core\Config\Entity\ConfigEntityBase;
+
+/**
+ * Defines the robot entity.
+ *
+ * The lines below, starting with '@ConfigEntityType,' are a plugin annotation.
+ * These define the entity type to the entity type manager.
+ *
+ * The properties in the annotation are as follows:
+ *  - id: The machine name of the entity type.
+ *  - label: The human-readable label of the entity type. We pass this through
+ *    the "@Translation" wrapper so that the multilingual system may
+ *    translate it in the user interface.
+ *  - handlers: An array of entity handler classes, keyed by handler type.
+ *    - access: The class that is used for access checks.
+ *    - list_builder: The class that provides listings of the entity.
+ *    - form: An array of entity form classes keyed by their operation.
+ *  - entity_keys: Specifies the class properties in which unique keys are
+ *    stored for this entity type. Unique keys are properties which you know
+ *    will be unique, and which the entity manager can use as unique in database
+ *    queries.
+ *  - links: entity URL definitions. These are mostly used for Field UI.
+ *    Arbitrary keys can set here. For example, User sets cancel-form, while
+ *    Node uses delete-form.
+ *
+ * @see http://previousnext.com.au/blog/understanding-drupal-8s-config-entities
+ * @see annotation
+ * @see Drupal\Core\Annotation\Translation
+ *
+ * @ingroup config_entity_example
+ *
+ * @ConfigEntityType(
+ *   id = "robot",
+ *   label = @Translation("Robot"),
+ *   admin_permission = "administer robots",
+ *   handlers = {
+ *     "access" = "Drupal\config_entity_example\RobotAccessController",
+ *     "list_builder" = "Drupal\config_entity_example\Controller\RobotListBuilder",
+ *     "form" = {
+ *       "add" = "Drupal\config_entity_example\Form\RobotAddForm",
+ *       "edit" = "Drupal\config_entity_example\Form\RobotEditForm",
+ *       "delete" = "Drupal\config_entity_example\Form\RobotDeleteForm"
+ *     }
+ *   },
+ *   entity_keys = {
+ *     "id" = "id",
+ *     "label" = "label"
+ *   },
+ *   links = {
+ *     "edit-form" = "/examples/config_entity_example/manage/{robot}",
+ *     "delete-form" = "/examples/config_entity_example/manage/{robot}/delete"
+ *   }
+ * )
+ */
+class Robot extends ConfigEntityBase {
+
+  /**
+   * The robot ID.
+   *
+   * @var string
+   */
+  public $id;
+
+  /**
+   * The robot UUID.
+   *
+   * @var string
+   */
+  public $uuid;
+
+  /**
+   * The robot label.
+   *
+   * @var string
+   */
+  public $label;
+
+  /**
+   * The robot floopy flag.
+   *
+   * @var string
+   */
+  public $floopy;
+}

+<?php
+
+/**
+ * @file
+ * Contains Drupal\config_entity_example\Form\RobotAddForm.
+ */
+
+namespace Drupal\config_entity_example\Form;
+
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Class RobotAddForm.
+ *
+ * Provides the add form for our Robot entity.
+ *
+ * @package Drupal\config_entity_example\Form
+ *
+ * @ingroup config_entity_example
+ */
+class RobotAddForm extends RobotFormBase {
+
+  /**
+   * Returns the actions provided by this form.
+   *
+   * For our add form, we only need to change the text of the submit button.
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param \Drupal\Core\Form\FormStateInterface $form_state
+   *   An associative array containing the current state of the form.
+   *
+   * @return array
+   *   An array of supported actions for the current entity form.
+   */
+  protected function actions(array $form, FormStateInterface $form_state) {
+    $actions = parent::actions($form, $form_state);
+    $actions['submit']['#value'] = $this->t('Create Robot');
+    return $actions;
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains Drupal\config_entity_example\Form\RobotDeleteForm.
+ */
+
+namespace Drupal\config_entity_example\Form;
+
+use Drupal\Core\Entity\EntityConfirmFormBase;
+use Drupal\Core\Url;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Class RobotDeleteForm.
+ *
+ * Provides a confirm form for deleting the entity. This is different from the
+ * add and edit forms as it does not inherit from RobotFormBase. The reason for
+ * this is that we do not need to build the same form. Instead, we present the
+ * user with a simple yes/no question. For this reason, we derive from
+ * EntityConfirmFormBase instead.
+ *
+ * @package Drupal\config_entity_example\Form
+ *
+ * @ingroup config_entity_example
+ */
+class RobotDeleteForm extends EntityConfirmFormBase {
+
+  /**
+   * Gathers a confirmation question.
+   *
+   * The question is used as a title in our confirm form. For delete confirm
+   * forms, this typically takes the form of "Are you sure you want to
+   * delete...", including the entity label.
+   *
+   * @return string
+   *   Translated string.
+   */
+  public function getQuestion() {
+    return $this->t('Are you sure you want to delete robot %label?', array(
+        '%label' => $this->entity->label(),
+    ));
+  }
+
+  /**
+   * Gather the confirmation text.
+   *
+   * The confirm text is used as the text in the button that confirms the
+   * question posed by getQuestion().
+   *
+   * @return string
+   *   Translated string.
+   */
+  public function getConfirmText() {
+    return $this->t('Delete Robot');
+  }
+
+  /**
+   * Gets the cancel URL.
+   *
+   * Provides the URL to go to if the user cancels the action. For entity
+   * delete forms, this is typically the route that points at the list
+   * controller.
+   *
+   * @return \Drupal\Core\Url
+   *   The URL to go to if the user cancels the deletion.
+   */
+  public function getCancelUrl() {
+    return new Url('entity.robot.list');
+  }
+
+  /**
+   * The submit handler for the confirm form.
+   *
+   * For entity delete forms, you use this to delete the entity in
+   * $this->entity.
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param \Drupal\Core\Form\FormStateInterface $form_state
+   *   An associative array containing the current state of the form.
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    // Delete the entity.
+    $this->entity->delete();
+
+    // Set a message that the entity was deleted.
+    drupal_set_message(t('Robot %label was deleted.', array(
+      '%label' => $this->entity->label(),
+    )));
+
+    // Redirect the user to the list controller when complete.
+    $form_state->setRedirectUrl($this->getCancelUrl());
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains Drupal\config_entity_example\Form\RobotEditForm.
+ */
+
+namespace Drupal\config_entity_example\Form;
+
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Class RobotEditForm
+ *
+ * Provides the edit form for our Robot entity.
+ *
+ * @package Drupal\config_entity_example\Form
+ *
+ * @ingroup config_entity_example
+ */
+class RobotEditForm extends RobotFormBase {
+
+  /**
+   * Returns the actions provided by this form.
+   *
+   * For the edit form, we only need to change the text of the submit button.
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param \Drupal\Core\Form\FormStateInterface $form_state
+   *   An associative array containing the current state of the form.
+   *
+   * @return array
+   *   An array of supported actions for the current entity form.
+   */
+  public function actions(array $form, FormStateInterface $form_state) {
+    $actions = parent::actions($form, $form_state);
+    $actions['submit']['#value'] = t('Update Robot');
+    return $actions;
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains Drupal\config_entity_example\Form\RobotFormBase.
+ */
+
+namespace Drupal\config_entity_example\Form;
+
+use Drupal\Core\Entity\EntityForm;
+use Drupal\Core\Entity\Query\QueryFactory;
+use Drupal\Core\Form\FormStateInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Class RobotFormBase.
+ *
+ * Typically, we need to build the same form for both adding a new entity,
+ * and editing an existing entity. Instead of duplicating our form code,
+ * we create a base class. Drupal never routes to this class directly,
+ * but instead through the child classes of RobotAddForm and RobotEditForm.
+ *
+ * @package Drupal\config_entity_example\Form
+ *
+ * @ingroup config_entity_example
+ */
+class RobotFormBase extends EntityForm {
+
+  /**
+   * @var \Drupal\Core\Entity\Query\QueryFactory
+   */
+  protected $entityQueryFactory;
+
+  /**
+   * Construct the RobotFormBase.
+   *
+   * For simple entity forms, there's no need for a constructor. Our robot form
+   * base, however, requires an entity query factory to be injected into it
+   * from the container. We later use this query factory to build an entity
+   * query for the exists() method.
+   *
+   * @param \Drupal\Core\Entity\Query\QueryFactory $query_factory
+   *   An entity query factory for the robot entity type.
+   */
+  public function __construct(QueryFactory $query_factory) {
+    $this->entityQueryFactory = $query_factory;
+  }
+
+  /**
+   * Factory method for RobotFormBase.
+   *
+   * When Drupal builds this class it does not call the constructor directly.
+   * Instead, it relies on this method to build the new object. Why? The class
+   * constructor may take multiple arguments that are unknown to Drupal. The
+   * create() method always takes one parameter -- the container. The purpose
+   * of the create() method is twofold: It provides a standard way for Drupal
+   * to construct the object, meanwhile it provides you a place to get needed
+   * constructor parameters from the container.
+   *
+   * In this case, we ask the container for an entity query factory. We then
+   * pass the factory to our class as a constructor parameter.
+   */
+  public static function create(ContainerInterface $container) {
+    return new static($container->get('entity.query'));
+  }
+
+  /**
+   * Overrides Drupal\Core\Entity\EntityFormController::form().
+   *
+   * Builds the entity add/edit form.
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param array $form_state
+   *   An associative array containing the current state of the form.
+   *
+   * @return array
+   *   An associative array containing the robot add/edit form.
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    // Get anything we need from the base class.
+    $form = parent::buildForm($form, $form_state);
+
+    // Drupal provides the entity to us as a class variable. If this is an
+    // existing entity, it will be populated with existing values as class
+    // variables. If this is a new entity, it will be a new object with the
+    // class of our entity. Drupal knows which class to call from the
+    // annotation on our Robot class.
+    $robot = $this->entity;
+
+    // Build the form.
+    $form['label'] = array(
+      '#type' => 'textfield',
+      '#title' => $this->t('Label'),
+      '#maxlength' => 255,
+      '#default_value' => $robot->label(),
+      '#required' => TRUE,
+    );
+    $form['id'] = array(
+      '#type' => 'machine_name',
+      '#title' => $this->t('Machine name'),
+      '#default_value' => $robot->id(),
+      '#machine_name' => array(
+        'exists' => array($this, 'exists'),
+        'replace_pattern' => '([^a-z0-9_]+)|(^custom$)',
+        'error' => 'The machine-readable name must be unique, and can only contain lowercase letters, numbers, and underscores. Additionally, it can not be the reserved word "custom".',
+      ),
+      '#disabled' => !$robot->isNew(),
+    );
+    $form['floopy'] = array(
+      '#type' => 'checkbox',
+      '#title' => $this->t('Floopy'),
+      '#default_value' => $robot->floopy,
+    );
+
+    // Return the form.
+    return $form;
+  }
+
+  /**
+   * Checks for an existing robot.
+   *
+   * @param string|int $entity_id
+   *   The entity ID.
+   * @param array $element
+   *   The form element.
+   * @param FormStateInterface $form_state
+   *   The form state.
+   *
+   * @return bool
+   *   TRUE if this format already exists, FALSE otherwise.
+   */
+  public function exists($entity_id, array $element, FormStateInterface $form_state) {
+    // Use the query factory to build a new robot entity query.
+    $query = $this->entityQueryFactory->get('robot');
+
+    // Query the entity ID to see if its in use.
+    $result = $query->condition('id', $element['#field_prefix'] . $entity_id)
+      ->execute();
+
+    // We don't need to return the ID, only if it exists or not.
+    return (bool) $result;
+  }
+
+  /**
+   * Overrides Drupal\Core\Entity\EntityFormController::actions().
+   *
+   * To set the submit button text, we need to override actions().
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param \Drupal\Core\Form\FormStateInterface $form_state
+   *   An associative array containing the current state of the form.
+   *
+   * @return array
+   *   An array of supported actions for the current entity form.
+   */
+  protected function actions(array $form, FormStateInterface $form_state) {
+    // Get the basic actins from the base class.
+    $actions = parent::actions($form, $form_state);
+
+    // Change the submit button text.
+    $actions['submit']['#value'] = $this->t('Save');
+
+    // Return the result.
+    return $actions;
+  }
+
+  /**
+   * Overrides Drupal\Core\Entity\EntityFormController::validate().
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param \Drupal\Core\Form\FormStateInterface $form_state
+   *   An associative array containing the current state of the form.
+   */
+  public function validate(array $form, FormStateInterface $form_state) {
+    parent::validate($form, $form_state);
+
+    // Add code here to validate your config entity's form elements.
+    // Nothing to do here.
+  }
+
+  /**
+   * Overrides Drupal\Core\Entity\EntityFormController::save().
+   *
+   * Saves the entity. This is called after submit() has built the entity from
+   * the form values. Do not override submit() as save() is the preferred
+   * method for entity form controllers.
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param \Drupal\Core\Form\FormStateInterface $form_state
+   *   An associative array containing the current state of the form.
+   */
+  public function save(array $form, FormStateInterface $form_state) {
+    // EntityForm provides us with the entity we're working on.
+    $robot = $this->getEntity();
+
+    // Drupal already populated the form values in the entity object. Each
+    // form field was saved as a public variable in the entity class. PHP
+    // allows Drupal to do this even if the method is not defined ahead of
+    // time.
+    $status = $robot->save();
+
+    // Grab the URL of the new entity. We'll use it in the message.
+    $url = $robot->urlInfo();
+
+    // Create an edit link.
+    $edit_link = $this->l(t('Edit'), $url);
+
+    if ($status == SAVED_UPDATED) {
+      // If we edited an existing entity...
+      drupal_set_message($this->t('Robot %label has been updated.', array('%label' => $robot->label())));
+      $this->logger('contact')->notice('Robot %label has been updated.', ['%label' => $robot->label(), 'link' => $edit_link]);
+    }
+    else {
+      // If we created a new entity...
+      drupal_set_message($this->t('Robot %label has been added.', array('%label' => $robot->label())));
+      $this->logger('contact')->notice('Robot %label has been added.', ['%label' => $robot->label(), 'link' => $edit_link]);
+    }
+
+    // Redirect the user back to the listing route after the save operation.
+    $form_state->setRedirect('entity.robot.list');
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\config_entity_example\RobotAccessController.
+ */
+
+namespace Drupal\config_entity_example;
+
+use Drupal\Core\Entity\EntityAccessControlHandler;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Session\AccountInterface;
+
+/**
+ * Defines an access controller for the robot entity.
+ *
+ * We set this class to be the access controller in Robot's entity annotation.
+ *
+ * @see \Drupal\config_entity_example\Entity\Robot
+ *
+ * @ingroup config_entity_example
+ */
+class RobotAccessController extends EntityAccessControlHandler {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function checkAccess(EntityInterface $entity, $operation, AccountInterface $account) {
+    // The $opereration parameter tells you what sort of operation access is
+    // being checked for.
+    if ($operation == 'view') {
+      return TRUE;
+    }
+    // Other than the view operation, we're going to be insanely lax about
+    // access. Don't try this at home!
+    return parent::checkAccess($entity, $operation, $account);
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Test case for testing the Config Entity Example module.
+ */
+
+namespace Drupal\config_entity_example\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Test the Config Entity Example module.
+ *
+ * @group config_entity_example
+ * @group examples
+ *
+ * @ingroup config_entity_example
+ */
+class ConfigEntityExampleTest extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('config_entity_example');
+
+  /**
+   * The installation profile to use with this test.
+   *
+   * We need the 'minimal' profile in order to make sure the Tool block is
+   * available.
+   *
+   * @var string
+   */
+  protected $profile = 'minimal';
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getInfo() {
+    return array(
+      'name' => 'Config Entity Example functional test',
+      'description' => 'Test the Config Entity Example module.',
+      'group' => 'Examples',
+    );
+  }
+
+  /**
+   * Various functional test of the Config Entity Example module.
+   *
+   * 1) Verify that the Marvin entity was created when the module was installed.
+   *
+   * 2) Verify that permissions are applied to the various defined paths.
+   *
+   * 3) Verify that we can manage entities through the user interface.
+   *
+   * 4) Verify that the entity we add can be re-edited.
+   *
+   * 5) Verify that the label is shown in the list.
+   */
+  public function testConfigEntityExample() {
+    // 1) Verify that the Marvin entity was created when the module was
+    // installed.
+    $entity = entity_load('robot', 'marvin');
+    $this->assertNotNull($entity, 'Marvin was created during installation.');
+
+    // 2) Verify that permissions are applied to the various defined paths.
+    // Define some paths. Since the Marvin entity is defined, we can use it
+    // in our management paths.
+    $forbidden_paths = array(
+      '/examples/config_entity_example',
+      '/examples/config_entity_example/add',
+      '/examples/config_entity_example/manage/marvin',
+      '/examples/config_entity_example/manage/marvin/delete',
+    );
+    // Check each of the paths to make sure we don't have access. At this point
+    // we haven't logged in any users, so the client is anonymous.
+    foreach ($forbidden_paths as $path) {
+      $this->drupalGet($path);
+      $this->assertResponse(403, "Access denied to anonymous for path: $path");
+    }
+
+    // Create a user with no permissions.
+    $noperms_user = $this->drupalCreateUser();
+    $this->drupalLogin($noperms_user);
+    // Should be the same result for forbidden paths, since the user needs
+    // special permissions for these paths.
+    foreach ($forbidden_paths as $path) {
+      $this->drupalGet($path);
+      $this->assertResponse(403, "Access denied to generic user for path: $path");
+    }
+
+    // Create a user who can administer robots.
+    $admin_user = $this->drupalCreateUser(array('administer robots'));
+    $this->drupalLogin($admin_user);
+    // Forbidden paths aren't forbidden any more.
+    foreach ($forbidden_paths as $unforbidden) {
+      $this->drupalGet($unforbidden);
+      $this->assertResponse(200, "Access granted to admin user for path: $unforbidden");
+    }
+
+    // Now that we have the admin user logged in, check the menu links.
+    $this->drupalGet('');
+    $this->assertLinkByHref('examples/config_entity_example');
+
+    // 3) Verify that we can manage entities through the user interface.
+    // We still have the admin user logged in, so we'll create, update, and
+    // delete an entity.
+    // Go to the list page.
+    $this->drupalGet('/examples/config_entity_example');
+    $this->clickLink('Add robot');
+    $robot_machine_name = 'roboname';
+    $this->drupalPostForm(
+      NULL,
+      array(
+        'label' => $robot_machine_name,
+        'id' => $robot_machine_name,
+        'floopy' => TRUE,
+      ),
+      t('Create Robot')
+    );
+
+    // 4) Verify that our robot appears when we edit it.
+    $this->drupalGet('/examples/config_entity_example/manage/' . $robot_machine_name);
+    $this->assertField('label');
+    $this->assertFieldChecked('edit-floopy');
+
+    // 5) Verify that the label and machine name are shown in the list.
+    $this->drupalGet('/examples/config_entity_example');
+    $this->clickLink('Add robot');
+    $robby_machine_name = 'robby_machine_name';
+    $robby_label = 'Robby label';
+    $this->drupalPostForm(
+      NULL,
+      array(
+        'label' => $robby_label,
+        'id' => $robby_machine_name,
+        'floopy' => TRUE,
+      ),
+      t('Create Robot')
+    );
+    $this->drupalGet('/examples/config_entity_example');
+    $this->assertText($robby_label);
+    $this->assertText($robby_machine_name);
+  }
+
+}

+name: Content Entity Example
+type: module
+description: 'Provides ContentEntityExampleContact entity.'
+package: Example modules
+# core: 8.x
+# These modules are required by the tests, must be available at bootstrap time
+dependencies:
+  - options
+  - entity_reference
+  - examples
+
+# Information added by Drupal.org packaging script on 2015-11-11
+version: '8.x-1.x-dev'
+core: '8.x'
+project: 'examples'
+datestamp: 1447204146

+# All action links for this module
+
+content_entity_example.contact_add:
+  # Which route will be called by the link
+  route_name: content_entity_example.contact_add
+  title: 'Add Contact'
+
+  # Where will the link appear, defined by route name.
+  appears_on:
+    - entity.content_entity_example_contact.collection
+    - entity.content_entity_example_contact.canonical

+# Define the menu links for this module
+
+entity.content_entity_example_contact.collection:
+  title: 'Content Entity Example: Contacts Listing'
+  route_name: entity.content_entity_example_contact.collection
+  description: 'List Contacts'
+  weight: 10
+content_entity_example_contact.admin.structure.settings:
+  title: Contact Settings
+  description: 'Configure Contact entity'
+  route_name:  content_entity_example.contact_settings
+  parent: system.admin_structure

+# Define the 'local' links for the module
+
+contact.settings_tab:
+  route_name: content_entity_example.contact_settings
+  title: Settings
+  base_route: content_entity_example.contact_settings
+
+contact.view:
+  route_name: entity.content_entity_example_contact.canonical
+  base_route: entity.content_entity_example_contact.canonical
+  title: View
+
+contact.page_edit:
+  route_name: entity.content_entity_example_contact.edit_form
+  base_route: entity.content_entity_example_contact.canonical
+  title: Edit
+
+contact.delete_confirm:
+  route_name:  entity.content_entity_example_contact.delete_form
+  base_route:  entity.content_entity_example_contact.canonical
+  title: Delete
+  weight: 10

+<?php
+
+/**
+ * @file
+ * Contains Drupal\content_entity_example\content_entity_example.module
+ */
+
+/**
+ * @defgroup content_entity_example Example: Content Entity
+ * @ingroup examples
+ * @{
+ * Implement a Content entity.
+ *
+ * This module demonstrates implementing a Content Entity.
+ *
+ * This is an example of a fieldable content entity used to hold structured
+ * information without the overhead of using a content type. It is defined
+ * programmatically and we will expose the main techniques to handle and expose
+ * the contents.
+ *
+ * We define a content entity named 'Contact'. With it, we demonstrate the main
+ * tasks for an entity:
+ * - define
+ * - save
+ * - load
+ * - view
+ * - edit
+ * - delete
+ * - control access
+ *
+ * Where ever possible, we use the amazing tools built into D8 natively.
+ * }
+ */

+'delete contact entity':
+  title: Delete entity content.
+'add contact entity':
+  title: Add entity content
+'view contact entity':
+  title: View entity content
+'edit contact entity':
+  title: Edit entity content
+'administer contact entity':
+  title: Administer settings

+# This file brings everything together. Very nifty!
+
+# Route name can be used in sevaral place (links, redirects, local actions etc.)
+entity.content_entity_example_contact.canonical:
+  path: '/content_entity_example_contact/{content_entity_example_contact}'
+  defaults:
+  # Calls the view controller, defined in the annotation of the contact entity
+    _entity_view: 'content_entity_example_contact'
+    _title: 'Contact Content'
+  requirements:
+  # Calls the access controller of the entity, $operation 'view'
+    _entity_access: 'content_entity_example_contact.view'
+
+entity.content_entity_example_contact.collection:
+  path: '/content_entity_example_contact/list'
+  defaults:
+  # Calls the list controller, defined in the annotation of the contact entity.
+    _entity_list: 'content_entity_example_contact'
+    _title: 'Contact List'
+  requirements:
+  # Checks for permission directly.
+    _permission: 'view contact entity'
+
+content_entity_example.contact_add:
+  path: '/content_entity_example_contact/add'
+  defaults:
+  # Calls the form.add controller, defined in the contact entity.
+    _entity_form: content_entity_example_contact.add
+    _title: 'Add Contact'
+  requirements:
+    _entity_create_access: 'content_entity_example_contact'
+
+entity.content_entity_example_contact.edit_form:
+  path: '/content_entity_example_contact/{content_entity_example_contact}/edit'
+  defaults:
+  # Calls the form.edit controller, defined in the contact entity.
+    _entity_form: content_entity_example_contact.edit
+    _title: 'Edit Contact'
+  requirements:
+    _entity_access: 'content_entity_example_contact.edit'
+
+entity.content_entity_example_contact.delete_form:
+  path: '/contact/{content_entity_example_contact}/delete'
+  defaults:
+    # Calls the form.delete controller, defined in the contact entity.
+    _entity_form: content_entity_example_contact.delete
+    _title: 'Delete Contact'
+  requirements:
+    _entity_access: 'content_entity_example_contact.delete'
+
+content_entity_example.contact_settings:
+  path: 'admin/structure/content_entity_example_contact_settings'
+  defaults:
+    _form: '\Drupal\content_entity_example\Form\ContactSettingsForm'
+    _title: 'Contact Settings'
+  requirements:
+    _permission: 'administer contact entity'

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\content_entity_example\ContactAccessControlHandler
+ */
+
+namespace Drupal\content_entity_example;
+
+use Drupal\Core\Access\AccessResult;
+use Drupal\Core\Entity\EntityAccessControlHandler;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Session\AccountInterface;
+
+/**
+ * Access controller for the comment entity.
+ *
+ * @see \Drupal\comment\Entity\Comment.
+ */
+class ContactAccessControlHandler extends EntityAccessControlHandler {
+
+  /**
+   * {@inheritdoc}
+   *
+   * Link the activities to the permissions. checkAccess is called with the
+   * $operation as defined in the routing.yml file.
+   */
+  protected function checkAccess(EntityInterface $entity, $operation, AccountInterface $account) {
+    switch ($operation) {
+      case 'view':
+        return AccessResult::allowedIfHasPermission($account, 'view contact entity');
+
+      case 'edit':
+        return AccessResult::allowedIfHasPermission($account, 'edit contact entity');
+
+      case 'delete':
+        return AccessResult::allowedIfHasPermission($account, 'delete contact entity');
+    }
+    return AccessResult::allowed();
+  }
+
+  /**
+   * {@inheritdoc}
+   *
+   * Separate from the checkAccess because the entity does not yet exist, it
+   * will be created during the 'add' process.
+   */
+  protected function checkCreateAccess(AccountInterface $account, array $context, $entity_bundle = NULL) {
+    return AccessResult::allowedIfHasPermission($account, 'add contact entity');
+  }
+
+}

+<?php
+/**
+ * @file
+ * Contains \Drupal\content_entity_example\ContactInterface.
+ */
+
+namespace Drupal\content_entity_example;
+
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\user\EntityOwnerInterface;
+use Drupal\Core\Entity\EntityChangedInterface;
+
+/**
+ * Provides an interface defining a Contact entity.
+ *
+ * We have this interface so we can join the other interfaces it extends.
+ *
+ * @ingroup content_entity_example
+ */
+interface ContactInterface extends ContentEntityInterface, EntityOwnerInterface, EntityChangedInterface {
+
+}

+<?php
+/**
+ * @file
+ * Contains \Drupal\content_entity_example\Entity\ContentEntityExample.
+ */
+
+namespace Drupal\content_entity_example\Entity;
+
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Field\BaseFieldDefinition;
+use Drupal\Core\Entity\ContentEntityBase;
+use Drupal\Core\Entity\EntityTypeInterface;
+use Drupal\content_entity_example\ContactInterface;
+use Drupal\user\UserInterface;
+use Drupal\Core\Entity\EntityChangedTrait;
+
+/**
+ * Defines the ContentEntityExample entity.
+ *
+ * @ingroup content_entity_example
+ *
+ * This is the main definition of the entity type. From it, an entityType is
+ * derived. The most important properties in this example are listed below.
+ *
+ * id: The unique identifier of this entityType. It follows the pattern
+ * 'moduleName_xyz' to avoid naming conflicts.
+ *
+ * label: Human readable name of the entity type.
+ *
+ * handlers: Handler classes are used for different tasks. You can use
+ * standard handlers provided by D8 or build your own, most probably derived
+ * from the standard class. In detail:
+ *
+ * - view_builder: we use the standard controller to view an instance. It is
+ *   called when a route lists an '_entity_view' default for the entityType
+ *   (see routing.yml for details. The view can be manipulated by using the
+ *   standard drupal tools in the settings.
+ *
+ * - list_builder: We derive our own list builder class from the
+ *   entityListBuilder to control the presentation.
+ *   If there is a view available for this entity from the views module, it
+ *   overrides the list builder. @todo: any view? naming convention?
+ *
+ * - form: We derive our own forms to add functionality like additional fields,
+ *   redirects etc. These forms are called when the routing list an
+ *   '_entity_form' default for the entityType. Depending on the suffix
+ *   (.add/.edit/.delete) in the route, the correct form is called.
+ *
+ * - access: Our own accessController where we determine access rights based on
+ *   permissions.
+ *
+ * More properties:
+ *
+ *  - base_table: Define the name of the table used to store the data. Make sure
+ *    it is unique. The schema is automatically determined from the
+ *    BaseFieldDefinitions below. The table is automatically created during
+ *    installation.
+ *
+ *  - fieldable: Can additional fields be added to the entity via the GUI?
+ *    Analog to content types.
+ *
+ *  - entity_keys: How to access the fields. Analog to 'nid' or 'uid'.
+ *
+ *  - links: Provide links to do standard tasks. The 'edit-form' and
+ *    'delete-form' links are added to the list built by the
+ *    entityListController. They will show up as action buttons in an additional
+ *    column.
+ *
+ * There are many more properties to be used in an entity type definition. For
+ * a complete overview, please refer to the '\Drupal\Core\Entity\EntityType'
+ * class definition.
+ *
+ * The following construct is the actual definition of the entity type which
+ * is read and cached. Don't forget to clear cache after changes.
+ *
+ * @ContentEntityType(
+ *   id = "content_entity_example_contact",
+ *   label = @Translation("Contact entity"),
+ *   handlers = {
+ *     "view_builder" = "Drupal\Core\Entity\EntityViewBuilder",
+ *     "list_builder" = "Drupal\content_entity_example\Entity\Controller\ContactListBuilder",
+ *     "form" = {
+ *       "add" = "Drupal\content_entity_example\Form\ContactForm",
+ *       "edit" = "Drupal\content_entity_example\Form\ContactForm",
+ *       "delete" = "Drupal\content_entity_example\Form\ContactDeleteForm",
+ *     },
+ *     "access" = "Drupal\content_entity_example\ContactAccessControlHandler",
+ *   },
+ *   list_cache_contexts = { "user" },
+ *   base_table = "contact",
+ *   admin_permission = "administer content_entity_example entity",
+ *   fieldable = TRUE,
+ *   entity_keys = {
+ *     "id" = "id",
+ *     "label" = "name",
+ *     "uuid" = "uuid"
+ *   },
+ *   links = {
+ *     "canonical" = "/content_entity_example_contact/{content_entity_example_contact}",
+ *     "edit-form" = "/content_entity_example_contact/{content_entity_example_contact}/edit",
+ *     "delete-form" = "/contact/{content_entity_example_contact}/delete",
+ *     "collection" = "/content_entity_example_contact/list"
+ *   },
+ *   field_ui_base_route = "content_entity_example.contact_settings",
+ * )
+ *
+ * The 'links' above are defined by their path. For core to find the
+ * corresponding route, the route name must follow the correct pattern:
+ *
+ * entity.<entity-name>.<link-name> (replace dashes with underscores)
+ * Example: 'entity.content_entity_example_contact.canonical'
+ *
+ * See routing file above for the corresponding implementation
+ *
+ * The Contact class defines methods and fields for the contact entity.
+ *
+ * Being derived from the ContentEntityBase class, we can override the methods
+ * we want. In our case we want to provide access to the standard fields about
+ * creation and changed time stamps.
+ *
+ * Our interface (see ContactInterface) also exposes the EntityOwnerInterface.
+ * This allows us to provide methods for setting and providing ownership
+ * information.
+ *
+ * The most important part is the definitions of the field properties for this
+ * entity type. These are of the same type as fields added through the GUI, but
+ * they can by changed in code. In the definition we can define if the user with
+ * the rights privileges can influence the presentation (view, edit) of each
+ * field.
+ *
+ * The class also uses the EntityChangedTrait trait which allows it to record
+ * timestamps of save operations.
+ */
+class Contact extends ContentEntityBase implements ContactInterface {
+
+  use EntityChangedTrait;
+
+  /**
+   * {@inheritdoc}
+   *
+   * When a new entity instance is added, set the user_id entity reference to
+   * the current user as the creator of the instance.
+   */
+  public static function preCreate(EntityStorageInterface $storage_controller, array &$values) {
+    parent::preCreate($storage_controller, $values);
+    $values += array(
+      'user_id' => \Drupal::currentUser()->id(),
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCreatedTime() {
+    return $this->get('created')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getChangedTime() {
+    return $this->get('changed')->value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getOwner() {
+    return $this->get('user_id')->entity;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getOwnerId() {
+    return $this->get('user_id')->target_id;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setOwnerId($uid) {
+    $this->set('user_id', $uid);
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setOwner(UserInterface $account) {
+    $this->set('user_id', $account->id());
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   *
+   * Define the field properties here.
+   *
+   * Field name, type and size determine the table structure.
+   *
+   * In addition, we can define how the field and its content can be manipulated
+   * in the GUI. The behaviour of the widgets used can be determined here.
+   */
+  public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
+
+    // Standard field, used as unique if primary index.
+    $fields['id'] = BaseFieldDefinition::create('integer')
+      ->setLabel(t('ID'))
+      ->setDescription(t('The ID of the Contact entity.'))
+      ->setReadOnly(TRUE);
+
+    // Standard field, unique outside of the scope of the current project.
+    $fields['uuid'] = BaseFieldDefinition::create('uuid')
+      ->setLabel(t('UUID'))
+      ->setDescription(t('The UUID of the Contact entity.'))
+      ->setReadOnly(TRUE);
+
+    // Name field for the contact.
+    // We set display options for the view as well as the form.
+    // Users with correct privileges can change the view and edit configuration.
+    $fields['name'] = BaseFieldDefinition::create('string')
+      ->setLabel(t('Name'))
+      ->setDescription(t('The name of the Contact entity.'))
+      ->setSettings(array(
+        'default_value' => '',
+        'max_length' => 255,
+        'text_processing' => 0,
+      ))
+      ->setDisplayOptions('view', array(
+        'label' => 'above',
+        'type' => 'string',
+        'weight' => -6,
+      ))
+      ->setDisplayOptions('form', array(
+        'type' => 'string',
+        'weight' => -6,
+      ))
+      ->setDisplayConfigurable('form', TRUE)
+      ->setDisplayConfigurable('view', TRUE);
+
+    $fields['first_name'] = BaseFieldDefinition::create('string')
+      ->setLabel(t('First Name'))
+      ->setDescription(t('The first name of the Contact entity.'))
+      ->setSettings(array(
+        'default_value' => '',
+        'max_length' => 255,
+        'text_processing' => 0,
+      ))
+      ->setDisplayOptions('view', array(
+        'label' => 'above',
+        'type' => 'string',
+        'weight' => -5,
+      ))
+      ->setDisplayOptions('form', array(
+        'type' => 'string',
+        'weight' => -5,
+      ))
+      ->setDisplayConfigurable('form', TRUE)
+      ->setDisplayConfigurable('view', TRUE);
+
+    // Gender field for the contact.
+    // ListTextType with a drop down menu widget.
+    // The values shown in the menu are 'male' and 'female'.
+    // In the view the field content is shown as string.
+    // In the form the choices are presented as options list.
+    $fields['gender'] = BaseFieldDefinition::create('list_string')
+      ->setLabel(t('Gender'))
+      ->setDescription(t('The gender of the Contact entity.'))
+      ->setSettings(array(
+        'allowed_values' => array(
+          'female' => 'female',
+          'male' => 'male',
+        ),
+      ))
+      ->setDisplayOptions('view', array(
+        'label' => 'above',
+        'type' => 'string',
+        'weight' => -4,
+      ))
+      ->setDisplayOptions('form', array(
+        'type' => 'options_select',
+        'weight' => -4,
+      ))
+      ->setDisplayConfigurable('form', TRUE)
+      ->setDisplayConfigurable('view', TRUE);
+
+    // Owner field of the contact.
+    // Entity reference field, holds the reference to the user object.
+    // The view shows the user name field of the user.
+    // The form presents a auto complete field for the user name.
+    $fields['user_id'] = BaseFieldDefinition::create('entity_reference')
+      ->setLabel(t('User Name'))
+      ->setDescription(t('The Name of the associated user.'))
+      ->setSetting('target_type', 'user')
+      ->setSetting('handler', 'default')
+      ->setDisplayOptions('view', array(
+        'label' => 'above',
+        'type' => 'entity_reference',
+        'weight' => -3,
+      ))
+      ->setDisplayOptions('form', array(
+        'type' => 'entity_reference_autocomplete',
+        'settings' => array(
+          'match_operator' => 'CONTAINS',
+          'size' => 60,
+          'placeholder' => '',
+        ),
+        'weight' => -3,
+      ))
+      ->setDisplayConfigurable('form', TRUE)
+      ->setDisplayConfigurable('view', TRUE);
+
+    $fields['langcode'] = BaseFieldDefinition::create('language')
+      ->setLabel(t('Language code'))
+      ->setDescription(t('The language code of ContentEntityExample entity.'));
+    $fields['created'] = BaseFieldDefinition::create('created')
+      ->setLabel(t('Created'))
+      ->setDescription(t('The time that the entity was created.'));
+
+    $fields['changed'] = BaseFieldDefinition::create('changed')
+      ->setLabel(t('Changed'))
+      ->setDescription(t('The time that the entity was last edited.'));
+
+    return $fields;
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\content_entity_example\Entity\Controller\ContentEntityExampleController.
+ */
+
+namespace Drupal\content_entity_example\Entity\Controller;
+
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Entity\EntityListBuilder;
+use Drupal\Core\Url;
+
+/**
+ * Provides a list controller for content_entity_example entity.
+ *
+ * @ingroup content_entity_example
+ */
+class ContactListBuilder extends EntityListBuilder {
+
+  /**
+   * {@inheritdoc}
+   *
+   * We override ::render() so that we can add our own content above the table.
+   * parent::render() is where EntityListBuilder creates the table using our
+   * buildHeader() and buildRow() implementations.
+   */
+  public function render() {
+    $build['description'] = array(
+      '#markup' => $this->t('Content Entity Example implements a Contacts model. These contacts are fieldable entities. You can manage the fields on the <a href="@adminlink">Contacts admin page</a>.', array(
+        '@adminlink' => \Drupal::urlGenerator()->generateFromRoute('content_entity_example.contact_settings'),
+      )),
+    );
+    $build['table'] = parent::render();
+    return $build;
+  }
+
+  /**
+   * {@inheritdoc}
+   *
+   * Building the header and content lines for the contact list.
+   *
+   * Calling the parent::buildHeader() adds a column for the possible actions
+   * and inserts the 'edit' and 'delete' links as defined for the entity type.
+   */
+  public function buildHeader() {
+    $header['id'] = $this->t('ContactID');
+    $header['name'] = $this->t('Name');
+    $header['first_name'] = $this->t('First Name');
+    $header['gender'] = $this->t('Gender');
+    return $header + parent::buildHeader();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildRow(EntityInterface $entity) {
+    /* @var $entity \Drupal\content_entity_example\Entity\Contact */
+    $row['id'] = $entity->id();
+    $row['name'] = $entity->link();
+    $row['first_name'] = $entity->first_name->value;
+    $row['gender'] = $entity->gender->value;
+    return $row + parent::buildRow($entity);
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\content_entity_example\Form\ContactDeleteForm.
+ */
+
+namespace Drupal\content_entity_example\Form;
+
+use Drupal\Core\Entity\ContentEntityConfirmFormBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Url;
+
+/**
+ * Provides a form for deleting a content_entity_example entity.
+ *
+ * @ingroup content_entity_example
+ */
+class ContactDeleteForm extends ContentEntityConfirmFormBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getQuestion() {
+    return $this->t('Are you sure you want to delete entity %name?', array('%name' => $this->entity->label()));
+  }
+
+  /**
+   * {@inheritdoc}
+   *
+   * If the delete command is canceled, return to the contact list.
+   */
+  public function getCancelURL() {
+    return new Url('entity.content_entity_example_contact.collection');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getConfirmText() {
+    return $this->t('Delete');
+  }
+
+  /**
+   * {@inheritdoc}
+   *
+   * Delete the entity and log the event. log() replaces the watchdog.
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    $entity = $this->getEntity();
+    $entity->delete();
+
+    \Drupal::logger('content_entity_example')->notice('@type: deleted %title.',
+      array(
+        '@type' => $this->entity->bundle(),
+        '%title' => $this->entity->label(),
+      ));
+    $form_state->setRedirect('entity.content_entity_example_contact.collection');
+  }
+
+}

+<?php
+/**
+ * @file
+ * Contains Drupal\content_entity_example\Form\ContactForm.
+ */
+
+namespace Drupal\content_entity_example\Form;
+
+use Drupal\Core\Entity\ContentEntityForm;
+use Drupal\Core\Language\Language;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Form controller for the content_entity_example entity edit forms.
+ *
+ * @ingroup content_entity_example
+ */
+class ContactForm extends ContentEntityForm {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    /* @var $entity \Drupal\content_entity_example\Entity\Contact */
+    $form = parent::buildForm($form, $form_state);
+    $entity = $this->entity;
+
+    $form['langcode'] = array(
+      '#title' => $this->t('Language'),
+      '#type' => 'language_select',
+      '#default_value' => $entity->getUntranslated()->language()->getId(),
+      '#languages' => Language::STATE_ALL,
+    );
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function save(array $form, FormStateInterface $form_state) {
+    $form_state->setRedirect('entity.content_entity_example_contact.collection');
+    $entity = $this->getEntity();
+    $entity->save();
+  }
+}

+<?php
+/**
+ * @file
+ * Contains Drupal\content_entity_example\Form\ContactSettingsForm.
+ */
+
+namespace Drupal\content_entity_example\Form;
+
+use Drupal\Core\Form\FormBase;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Class ContentEntityExampleSettingsForm.
+ * @package Drupal\content_entity_example\Form
+ * @ingroup content_entity_example
+ */
+class ContactSettingsForm extends FormBase {
+  /**
+   * Returns a unique string identifying the form.
+   *
+   * @return string
+   *   The unique string identifying the form.
+   */
+  public function getFormId() {
+    return 'content_entity_example_settings';
+  }
+
+  /**
+   * Form submission handler.
+   *
+   * @param FormStateInterface $form
+   *   An associative array containing the structure of the form.
+   * @param array $form_state
+   *   An associative array containing the current state of the form.
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    // Empty implementation of the abstract submit class.
+  }
+
+
+  /**
+   * Define the form used for ContentEntityExample settings.
+   * @return array
+   *   Form definition array.
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param FormStateInterface $form_state
+   *   An associative array containing the current state of the form.
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    $form['contact_settings']['#markup'] = 'Settings form for ContentEntityExample. Manage field settings here.';
+    return $form;
+  }
+}

+<?php
+
+/**
+ * @file
+ * Test cases for Content Entity Example Module.
+ */
+
+namespace Drupal\content_entity_example\Tests;
+
+use Drupal\content_entity_example\Entity\Contact;
+use Drupal\examples\Tests\ExamplesTestBase;
+
+/**
+ * Tests the basic functions of the Content Entity Example module.
+ *
+ * @package Drupal\content_entity_example\Tests
+ *
+ * @ingroup content_entity_example
+ *
+ * @group content_entity_example
+ * @group examples
+ */
+class ContentEntityExampleTest extends ExamplesTestBase {
+
+  public static $modules = array('content_entity_example', 'block', 'field_ui');
+
+  /**
+   * Basic tests for Content Entity Example.
+   */
+  public function testContentEntityExample() {
+    $web_user = $this->drupalCreateUser(array(
+      'add contact entity',
+      'edit contact entity',
+      'view contact entity',
+      'delete contact entity',
+      'administer contact entity',
+      'administer content_entity_example_contact display',
+      'administer content_entity_example_contact fields',
+      'administer content_entity_example_contact form display'));
+
+    // Anonymous User should not see the link to the listing.
+    $this->assertNoText(t('Content Entity Example: Contacts Listing'));
+
+    $this->drupalLogin($web_user);
+
+    // Web_user user has the right to view listing.
+    $this->assertLink(t('Content Entity Example: Contacts Listing'));
+
+    $this->clickLink(t('Content Entity Example: Contacts Listing'));
+
+    // WebUser can add entity content.
+    $this->assertLink(t('Add Contact'));
+
+    $this->clickLink(t('Add Contact'));
+
+    $this->assertFieldByName('name[0][value]', '', 'Name Field, empty');
+    $this->assertFieldByName('name[0][value]', '', 'First Name Field, empty');
+    $this->assertFieldByName('name[0][value]', '', 'Gender Field, empty');
+
+    $user_ref = $web_user->name->value . ' (' . $web_user->id() . ')';
+    $this->assertFieldByName('user_id[0][target_id]', $user_ref, 'User ID reference field points to web_user');
+
+    // Post content, save an instance. Go back to list after saving.
+    $edit = array(
+      'name[0][value]' => 'test name',
+      'first_name[0][value]' => 'test first name',
+      'gender' => 'male',
+    );
+    $this->drupalPostForm(NULL, $edit, t('Save'));
+
+    // Entity listed.
+    $this->assertLink(t('Edit'));
+    $this->assertLink(t('Delete'));
+
+    $this->clickLink('test name');
+
+    // Entity shown.
+    $this->assertText(t('test name'));
+    $this->assertText(t('test first name'));
+    $this->assertText(t('male'));
+    $this->assertLink(t('Add Contact'));
+    $this->assertLink(t('Edit'));
+    $this->assertLink(t('Delete'));
+
+    // Delete the entity.
+    $this->clickLink('Delete');
+
+    // Confirm deletion.
+    $this->assertLink(t('Cancel'));
+    $this->drupalPostForm(NULL, array(), 'Delete');
+
+    // Back to list, must be empty.
+    $this->assertNoText('test name');
+
+    // Settings page.
+    $this->drupalGet('admin/structure/content_entity_example_contact_settings');
+    $this->assertText(t('Contact Settings'));
+
+    // Make sure the field manipulation links are available.
+    $this->assertLink(t('Settings'));
+    $this->assertLink(t('Manage fields'));
+    $this->assertLink(t('Manage form display'));
+    $this->assertLink(t('Manage display'));
+  }
+
+  /**
+   * Test all paths exposed by the module, by permission.
+   */
+  public function testPaths() {
+    // Generate a contact so that we can test the paths against it.
+    $contact = Contact::create(
+      array(
+        'name' => 'somename',
+        'first_name' => 'Joe',
+        'gender' => 'female',
+      )
+    );
+    $contact->save();
+
+    // Gather the test data.
+    $data = $this->providerTestPaths($contact->id());
+
+    // Run the tests.
+    foreach ($data as $datum) {
+      // drupalCreateUser() doesn't know what to do with an empty permission
+      // array, so we help it out.
+      if ($datum[2]) {
+        $user = $this->drupalCreateUser(array($datum[2]));
+        $this->drupalLogin($user);
+      }
+      else {
+        $user = $this->drupalCreateUser();
+        $this->drupalLogin($user);
+      }
+      $this->drupalGet($datum[1]);
+      $this->assertResponse($datum[0]);
+    }
+  }
+
+  /**
+   * Data provider for testPaths.
+   *
+   * @param int $contact_id
+   *   The id of an existing Contact entity.
+   *
+   * @return array
+   *   Nested array of testing data. Arranged like this:
+   *   - Expected response code.
+   *   - Path to request.
+   *   - Permission for the user.
+   */
+  protected function providerTestPaths($contact_id) {
+    return array(
+      array(
+        200,
+        '/content_entity_example_contact/' . $contact_id,
+        'view contact entity',
+      ),
+      array(
+        403,
+        '/content_entity_example_contact/' . $contact_id,
+        '',
+      ),
+      array(
+        200,
+        '/content_entity_example_contact/list',
+        'view contact entity',
+      ),
+      array(
+        403,
+        '/content_entity_example_contact/list',
+        '',
+      ),
+      array(
+        200,
+        '/content_entity_example_contact/add',
+        'add contact entity',
+      ),
+      array(
+        403,
+        '/content_entity_example_contact/add',
+        '',
+      ),
+      array(
+        200,
+        '/content_entity_example_contact/' . $contact_id . '/edit',
+        'edit contact entity',
+      ),
+      array(
+        403,
+        '/content_entity_example_contact/' . $contact_id . '/edit',
+        '',
+      ),
+      array(
+        200,
+        '/contact/' . $contact_id . '/delete',
+        'delete contact entity',
+      ),
+      array(
+        403,
+        '/contact/' . $contact_id . '/delete',
+        '',
+      ),
+      array(
+        200,
+        'admin/structure/content_entity_example_contact_settings',
+        'administer contact entity',
+      ),
+      array(
+        403,
+        'admin/structure/content_entity_example_contact_settings',
+        '',
+      ),
+    );
+  }
+
+}

+name: Cron example
+type: module
+description: 'Demonstrates hook_cron() and related features'
+package: Example modules
+# core: 8.x
+dependencies:
+  - examples
+
+# Information added by Drupal.org packaging script on 2015-11-11
+version: '8.x-1.x-dev'
+core: '8.x'
+project: 'examples'
+datestamp: 1447204146

+cron_example.description:
+  title: Cron Example
+  route_name: cron_example

+<?php
+
+/**
+ * @file
+ * Demonstrates use of the Cron API in Drupal - hook_cron().
+ */
+
+/**
+ * @defgroup cron_example Example: Cron
+ * @ingroup examples
+ * @{
+ * Example using Cron API, including hook_cron() and @QueueWorker plugins
+ *
+ * This example is part of the Examples for Developers Project
+ * which you can download and experiment with at
+ * http://drupal.org/project/examples
+ */
+
+/**
+ * Implements hook_cron().
+ *
+ * We implement hook_cron() to do "background" processing. It gets called every
+ * time the Drupal cron runs. We then decide what has to happen in response.
+ *
+ * In this example, we log a message after the time given in its config
+ * variable 'next_execution'. Then we update that variable to a time in the
+ * future.
+ */
+function cron_example_cron() {
+  // We access our configuration.
+  $cron_config = \Drupal::configFactory()->getEditable('examples.cron');
+  // Default to an hourly interval. Of course, cron has to be running at least
+  // hourly for this to work.
+  $interval = $cron_config->get('interval');
+  $interval = !empty($interval) ? $interval : 3600;
+
+  // We usually don't want to act every time cron runs (which could be every
+  // minute) so keep a time for the next run in a variable.
+  $next_execution = $cron_config->get('next_execution');
+  $next_execution = !empty($next_execution) ? $next_execution : 0;
+  if (REQUEST_TIME >= $next_execution) {
+    // This is a silly example of a cron job.
+    // It just makes it obvious that the job has run without
+    // making any changes to your database.
+    \Drupal::logger('cron_example')->notice('cron_example ran');
+    if (\Drupal::state()->get('cron_example_show_status_message')) {
+      drupal_set_message(t('cron_example executed at %time', ['%time' => date_iso8601(REQUEST_TIME)]));
+      \Drupal::state()->set('cron_example_show_status_message', FALSE);
+    }
+    $cron_config->set('next_execution', REQUEST_TIME + $interval)->save();
+  }
+}
+
+/**
+ * @} End of "defgroup cron_example".
+ */

+cron_example:
+  path: '/examples/cron_example'
+  defaults:
+    _form: '\Drupal\cron_example\Form\CronExampleForm'
+    _title: 'Cron Example'
+  requirements:
+    _permission: 'access content'

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\cron_example\Form\CronExampleForm.
+ */
+
+namespace Drupal\cron_example\Form;
+
+use Drupal\Core\Config\ConfigFactoryInterface;
+use Drupal\Core\CronInterface;
+use Drupal\Core\Form\ConfigFormBase;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Queue\QueueFactory;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\Core\State\StateInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Form with examples on how to use cron.
+ */
+class CronExampleForm extends ConfigFormBase {
+
+  /**
+   * The current user.
+   *
+   * @var \Drupal\Core\Session\AccountInterface
+   */
+  protected $currentUser;
+
+  /**
+   * The cron service.
+   *
+   * @var \Drupal\Core\CronInterface
+   */
+  protected $cron;
+
+  /**
+   * The queue object.
+   *
+   * @var \Drupal\Core\Queue\QueueFactory
+   */
+  protected $queue;
+
+  /**
+   * The state keyvalue collection.
+   *
+   * @var \Drupal\Core\State\StateInterface
+   */
+  protected $state;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(ConfigFactoryInterface $config_factory, AccountInterface $current_user, CronInterface $cron, QueueFactory $queue, StateInterface $state) {
+    parent::__construct($config_factory);
+    $this->currentUser = $current_user;
+    $this->cron = $cron;
+    $this->queue = $queue;
+    $this->state = $state;
+
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container) {
+    return new static(
+      $container->get('config.factory'),
+      $container->get('current_user'),
+      $container->get('cron'),
+      $container->get('queue'),
+      $container->get('state')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId() {
+    return 'cron_example';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    $config = $this->configFactory->get('examples.cron');
+
+    $form['status'] = [
+      '#type' => 'details',
+      '#title' => $this->t('Cron status information'),
+      '#open' => TRUE,
+    ];
+    $form['status']['intro'] = [
+      '#type' => 'item',
+      '#markup' => $this->t('The cron example demonstrates hook_cron() and hook_queue_info() processing. If you have administrative privileges you can run cron from this page and see the results.'),
+    ];
+
+    $next_execution = $config->get('next_execution');
+    $next_execution = !empty($next_execution) ? $next_execution : REQUEST_TIME;
+
+    $args = [
+      '%time' => date_iso8601($config->get('next_execution')),
+      '%seconds' => $next_execution - REQUEST_TIME,
+    ];
+    $form['status']['last'] = [
+      '#type' => 'item',
+      '#markup' => $this->t('cron_example_cron() will next execute the first time cron runs after %time (%seconds seconds from now)', $args),
+    ];
+
+    if ($this->currentUser->hasPermission('administer site configuration')) {
+      $form['cron_run'] = [
+        '#type' => 'details',
+        '#title' => $this->t('Run cron manually'),
+        '#open' => TRUE,
+      ];
+      $form['cron_run']['cron_reset'] = [
+        '#type' => 'checkbox',
+        '#title' => $this->t('Run cron_example\'s cron regardless of whether interval has expired.'),
+        '#default_value' => FALSE,
+      ];
+      $form['cron_run']['cron_trigger']['actions'] = ['#type' => 'actions'];
+      $form['cron_run']['cron_trigger']['actions']['sumbit'] = [
+        '#type' => 'submit',
+        '#value' => $this->t('Run cron now'),
+        '#submit' => [[$this, 'cronRun']],
+      ];
+    }
+
+    $form['cron_queue_setup'] = [
+      '#type' => 'details',
+      '#title' => $this->t('Cron queue setup (for hook_cron_queue_info(), etc.)'),
+      '#open' => TRUE,
+    ];
+
+    $queue_1 = $this->queue->get('cron_example_queue_1');
+    $queue_2 = $this->queue->get('cron_example_queue_2');
+
+    $args = [
+      '%queue_1' => $queue_1->numberOfItems(),
+      '%queue_2' => $queue_2->numberOfItems(),
+    ];
+    $form['cron_queue_setup']['current_cron_queue_status'] = [
+      '#type' => 'item',
+      '#markup' => $this->t('There are currently %queue_1 items in queue 1 and %queue_2 items in queue 2', $args),
+    ];
+    $form['cron_queue_setup']['num_items'] = [
+      '#type' => 'select',
+      '#title' => $this->t('Number of items to add to queue'),
+      '#options' => array_combine([1, 5, 10, 100, 1000], [1, 5, 10, 100, 1000]),
+      '#default_value' => 5,
+    ];
+    $form['cron_queue_setup']['queue'] = [
+      '#type' => 'radios',
+      '#title' => $this->t('Queue to add items to'),
+      '#options' => [
+        'cron_example_queue_1' => $this->t('Queue 1'),
+        'cron_example_queue_2' => $this->t('Queue 2'),
+      ],
+      '#default_value' => 'cron_example_queue_1',
+    ];
+    $form['cron_queue_setup']['actions'] = ['#type' => 'actions'];
+    $form['cron_queue_setup']['actions']['submit'] = [
+      '#type' => 'submit',
+      '#value' => $this->t('Add jobs to queue'),
+      '#submit' => [[$this, 'addItems']],
+    ];
+
+    $form['configuration'] = [
+      '#type' => 'details',
+      '#title' => $this->t('Configuration of cron_example_cron()'),
+      '#open' => TRUE,
+    ];
+    $form['configuration']['cron_example_interval'] = [
+      '#type' => 'select',
+      '#title' => $this->t('Cron interval'),
+      '#description' => $this->t('Time after which cron_example_cron will respond to a processing request.'),
+      '#default_value' => $config->get('interval'),
+      '#options' => [
+        60 => $this->t('1 minute'),
+        300 => $this->t('5 minutes'),
+        3600 => $this->t('1 hour'),
+        86400 => $this->t('1 day'),
+      ],
+    ];
+
+    return parent::buildForm($form, $form_state);
+  }
+
+  /**
+   * Allow user to directly execute cron, optionally forcing it.
+   */
+  public function cronRun(array &$form, FormStateInterface &$form_state) {
+    $config = $this->configFactory->getEditable('examples.cron');
+
+    $cron_reset = $form_state->getValue('cron_reset');
+    if (!empty($cron_reset)) {
+      $config->set('next_execution', 0);
+    }
+
+    // Use a state variable to signal that cron was run manually from this form.
+    $this->state->set('cron_example_show_status_message', TRUE);
+    if ($this->cron->run()) {
+      drupal_set_message($this->t('Cron ran successfully.'));
+    }
+    else {
+      drupal_set_message($this->t('Cron run failed.'), 'error');
+    }
+  }
+
+  /**
+   * Add the items to the queue when signaled by the form.
+   */
+  public function addItems(array &$form, FormStateInterface &$form_state) {
+    $values = $form_state->getValues();
+    $queue_name = $form['cron_queue_setup']['queue'][$values['queue']]['#title'];
+    $num_items = $form_state->getValue('num_items');
+    // Queues are defined by a QueueWorker Plugin which are selected by their
+    // id attritbute.
+    // @see \Drupal\cron_example\Plugin\QueueWorker\ReportWorkerOne
+    $queue = $this->queue->get($values['queue']);
+
+    for ($i = 1; $i <= $num_items; $i++) {
+      // Create a new item, a new data object, which is passed to the
+      // QueueWorker's processItem() method.
+      $item = new \stdClass();
+      $item->created = REQUEST_TIME;
+      $item->sequence = $i;
+      $queue->createItem($item);
+    }
+
+    $args = [
+      '%num' => $num_items,
+      '%queue' => $queue_name,
+    ];
+    drupal_set_message($this->t('Added %num items to %queue', $args));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    // Update the interval as stored in configuration. This will be read when
+    // this modules hook_cron function fires and will be used to ensure that
+    // action is taken only after the appropiate time has elapsed.
+    $this->configFactory->getEditable('examples.cron')
+      ->set('interval', $form_state->getValue('cron_example_interval'))
+      ->save();
+
+    parent::submitForm($form, $form_state);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getEditableConfigNames() {
+    return ['examples.cron'];
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\cron_example\Plugin\QueueWorker\ReportWorkerBase.
+ */
+
+namespace Drupal\cron_example\Plugin\QueueWorker;
+
+use Drupal\Core\Queue\QueueWorkerBase;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+
+
+/**
+ * Provides base functionality for the ReportWorkers.
+ */
+abstract class ReportWorkerBase extends QueueWorkerBase {
+
+  use StringTranslationTrait;
+
+  /**
+   * Simple reporter log and display information about the queue.
+   *
+   * @param int $worker
+   *   Worker number.
+   * @param object $item
+   *   The $item which was stored in the cron queue.
+   */
+  protected function reportWork($worker, $item) {
+    if (\Drupal::state()->get('cron_example_show_status_message')) {
+      drupal_set_message(
+        $this->t('Queue @worker worker processed item with sequence @sequence created at @time', [
+        '@worker' => $worker,
+        '@sequence' => $item->sequence,
+        '@time' => date_iso8601($item->created),
+          ]
+        )
+      );
+    }
+    \Drupal::logger('cron_example')->info('Queue @worker worker processed item with sequence @sequence created at @time', [
+      '@worker' => $worker,
+      '@sequence' => $item->sequence,
+      '@time' => date_iso8601($item->created),
+      ]
+    );
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\cron_example\Plugin\QueueWorker\ReportWorkerOne.
+ */
+
+namespace Drupal\cron_example\Plugin\QueueWorker;
+
+/**
+ * A report worker.
+ *
+ * @QueueWorker(
+ *   id = "cron_example_queue_1",
+ *   title = @Translation("First worker in cron_example"),
+ *   cron = {"time" = 1}
+ * )
+ *
+ * QueueWorkers are new in Drupal 8. They define a queue, which in this case
+ * is identified as cron_example_queue_1 and contain a process that operates on
+ * all the data given to the queue.
+ *
+ * @see queue_example.module
+ */
+class ReportWorkerOne extends ReportWorkerBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function processItem($data) {
+    $this->reportWork(1, $data);
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\cron_example\Plugin\QueueWorker\ReportWorkerTwo.
+ */
+
+namespace Drupal\cron_example\Plugin\QueueWorker;
+
+/**
+ * A report worker.
+ *
+ * @QueueWorker(
+ *   id = "cron_example_queue_2",
+ *   title = @Translation("Second worker in cron_example"),
+ *   cron = {"time" = 20}
+ * )
+ *
+ * QueueWorkers are new in Drupal 8. They define a queue, which in this case
+ * is identified as cron_example_queue_2 and contain a process that operates on
+ * all the data given to the queue.
+ *
+ * @see queue_example.module
+ */
+class ReportWorkerTwo extends ReportWorkerBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function processItem($data) {
+    $this->reportWork(2, $data);
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Test case for testing the cron example module.
+ */
+
+/**
+ * @addtogroup cron_example
+ * @{
+ */
+
+namespace Drupal\cron_example\Tests;
+
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Test the functionality for the Cron Example.
+ *
+ * @ingroup cron_example
+ *
+ * @group cron_example
+ * @group examples
+ */
+class CronExampleTestCase extends WebTestBase {
+
+  /**
+   * An editable config object for access to 'examples.cron'.
+   *
+   * @var \Drupal\Core\Config\Config
+   */
+  protected $cronConfig;
+
+  /**
+   * Modules to install.
+   *
+   * @var array
+   */
+  public static $modules = ['cron_example', 'node'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUp() {
+    parent::setUp();
+    // Create user. Search content permission granted for the search block to
+    // be shown.
+    $this->drupalLogin($this->drupalCreateUser(['administer site configuration', 'access content']));
+
+    $this->cronConfig = \Drupal::configFactory()->getEditable('examples.cron');
+  }
+
+  /**
+   * Create an example node, test block through admin and user interfaces.
+   */
+  public function testCronExampleBasic() {
+    // Pretend that cron has never been run (even though simpletest seems to
+    // run it once...)
+    $this->cronConfig->set('cron_example_next_execution', 0);
+    $this->drupalGet('examples/cron_example');
+
+    // Initial run should cause cron_example_cron() to fire.
+    $post = [];
+    $this->drupalPostForm('examples/cron_example', $post, t('Run cron now'));
+    $this->assertText(t('cron_example executed at'));
+
+    // Forcing should also cause cron_example_cron() to fire.
+    $post['cron_reset'] = TRUE;
+    $this->drupalPostForm(NULL, $post, t('Run cron now'));
+    $this->assertText(t('cron_example executed at'));
+
+    // But if followed immediately and not forced, it should not fire.
+    $post['cron_reset'] = FALSE;
+    $this->drupalPostForm(NULL, $post, t('Run cron now'));
+    $this->assertNoText(t('cron_example executed at'));
+    $this->assertText(t('There are currently 0 items in queue 1 and 0 items in queue 2'));
+
+    $post = [
+      'num_items' => 5,
+      'queue' => 'cron_example_queue_1',
+    ];
+    $this->drupalPostForm(NULL, $post, t('Add jobs to queue'));
+    $this->assertText('There are currently 5 items in queue 1 and 0 items in queue 2');
+
+    $post = [
+      'num_items' => 100,
+      'queue' => 'cron_example_queue_2',
+    ];
+    $this->drupalPostForm(NULL, $post, t('Add jobs to queue'));
+    $this->assertText('There are currently 5 items in queue 1 and 100 items in queue 2');
+
+    $post = [];
+    $this->drupalPostForm('examples/cron_example', $post, t('Run cron now'));
+    $this->assertPattern('/Queue 1 worker processed item with sequence 5 /');
+    $this->assertPattern('/Queue 2 worker processed item with sequence 100 /');
+  }
+
+}
+
+/**
+ * @} End of "addtogroup cron_example".
+ */

+/**
+ * @file
+ * Styling for the user module icons.
+ */
+
+/**
+ * Toolbar tab icon.
+ */
+.toolbar-bar .toolbar-icon-examples:before {
+  background-image: url(../images/examples.svg);
+}
+.toolbar-bar .toolbar-icon-examples:active:before,
+.toolbar-bar .toolbar-icon-examples.active:before {
+  background-image: url(../images/examples.svg);
+}

+name: DBTNG example
+type: module
+description: 'An example module showing how use the database API: DBTNG.'
+package: Example modules
+# core: 8.x
+dependencies:
+  - examples
+  - user
+
+# Information added by Drupal.org packaging script on 2015-11-11
+version: '8.x-1.x-dev'
+core: '8.x'
+project: 'examples'
+datestamp: 1447204146

+<?php
+
+/**
+ * @file
+ * Install, update and uninstall functions for the dbtng_example module.
+ */
+
+/**
+ * Implements hook_install().
+ *
+ * Creates some default entries on this module custom table.
+ *
+ * @see hook_install()
+ * @ingroup dbtng_example
+ */
+function dbtng_example_install() {
+  // Add a default entry.
+  $fields = array(
+    'name' => 'John',
+    'surname' => 'Doe',
+    'age' => 0,
+  );
+  db_insert('dbtng_example')
+      ->fields($fields)
+      ->execute();
+
+  // Add another entry.
+  $fields = array(
+    'name' => 'John',
+    'surname' => 'Roe',
+    'age' => 100,
+    'uid' => 1,
+  );
+  db_insert('dbtng_example')
+      ->fields($fields)
+      ->execute();
+}
+
+/**
+ * Implements hook_schema().
+ *
+ * Defines the database tables used by this module.
+ *
+ * @see hook_schema()
+ * @ingroup dbtng_example
+ */
+function dbtng_example_schema() {
+  $schema['dbtng_example'] = array(
+    'description' => 'Stores example person entries for demonstration purposes.',
+    'fields' => array(
+      'pid' => array(
+        'type' => 'serial',
+        'not null' => TRUE,
+        'description' => 'Primary Key: Unique person ID.',
+      ),
+      'uid' => array(
+        'type' => 'int',
+        'not null' => TRUE,
+        'default' => 0,
+        'description' => "Creator user's {users}.uid",
+      ),
+      'name' => array(
+        'type' => 'varchar',
+        'length' => 255,
+        'not null' => TRUE,
+        'default' => '',
+        'description' => 'Name of the person.',
+      ),
+      'surname' => array(
+        'type' => 'varchar',
+        'length' => 255,
+        'not null' => TRUE,
+        'default' => '',
+        'description' => 'Surname of the person.',
+      ),
+      'age' => array(
+        'type' => 'int',
+        'not null' => TRUE,
+        'default' => 0,
+        'size' => 'tiny',
+        'description' => 'The age of the person in years.',
+      ),
+    ),
+    'primary key' => array('pid'),
+    'indexes' => array(
+      'name' => array('name'),
+      'surname' => array('surname'),
+      'age' => array('age'),
+    ),
+  );
+
+  return $schema;
+}

+dbtng_example.description:
+  title: DBTNG Example
+  route_name: dbtng_example
+
+dbtng_example.list:
+  title: List
+  route_name: dbtng_list
+  weight: 0
+  parent: dbtng_example.description
+dbtng_example.add:
+  title: Add entry
+  route_name: dbtng_add
+  weight: 1
+  parent: dbtng_example.description
+dbtng_example.update:
+  title: Update entry
+  route_name: dbtng_update
+  weight: 2
+  parent: dbtng_example.description
+dbtng_example.advanced:
+  title: Advanced list
+  route_name: dbtng_advanced
+  weight: 3
+  parent: dbtng_example.description

+<?php
+
+/**
+ * @file
+ * This is an example outlining how a module can make use of the new DBTNG
+ * database API.
+ *
+ * @todo Demonstrate transaction usage.
+ *
+ * General documentation is available at
+ * @link database Database abstraction layer documentation @endlink and
+ * at @link http://drupal.org/node/310069 @endlink.
+ */
+
+use Drupal\Core\Routing\RouteMatchInterface;
+
+/**
+ * @defgroup dbtng_example Example: Database (DBTNG)
+ * @ingroup examples
+ * @{
+ * Database examples, including DBTNG.
+ *
+ * 'DBTNG' means 'Database: The Next Generation.' Yes, Drupallers are nerds.
+ *
+ * General documentation is available at
+ * @link database.inc database abstraction layer documentation @endlink and
+ * at @link http://drupal.org/node/310069 Database API @endlink.
+ *
+ * The several examples in DBTNGExampleController (see
+ * /lib/Drupal/dbtng_example/DBTNGExampleController.php) demonstrate
+ * basic database usage.
+ *
+ * db_insert() example:
+ * @code
+ *   // INSERT INTO {dbtng_example} (name, surname) VALUES('John, 'Doe')
+ *   db_insert('dbtng_example')
+ *     ->fields(array('name' => 'John', 'surname' => 'Doe'))
+ *     ->execute();
+ * @endcode
+ *
+ * db_update() example:
+ * @code
+ *   // UPDATE {dbtng_example} SET name = 'Jane' WHERE name = 'John'
+ *   db_update('dbtng_example')
+ *     ->fields(array('name' => 'Jane'))
+ *     ->condition('name', 'John')
+ *     ->execute();
+ * @endcode
+ *
+ * db_delete() example:
+ * @code
+ *   // DELETE FROM {dbtng_example} WHERE name = 'Jane'
+ *   db_delete('dbtng_example')
+ *     ->condition('name', 'Jane')
+ *     ->execute();
+ * @endcode
+ *
+ * See @link database Database Abstraction Layer @endlink
+ * @see db_insert()
+ * @see db_update()
+ * @see db_delete()
+ */
+
+/**
+ * @} End of "defgroup dbtng_example".
+ */

+dbtng_example:
+  path: 'examples/dbtng_example'
+  defaults:
+    _title: 'DBTNG Example'
+    _controller: '\Drupal\dbtng_example\DBTNGExampleController::entryList'
+  requirements:
+    _permission: 'access content'
+
+dbtng_list:
+  path: 'examples/dbtng_example/list'
+  defaults:
+    _title: 'List'
+    _controller: '\Drupal\dbtng_example\DBTNGExampleController::entryList'
+  requirements:
+    _permission: 'access content'
+
+dbtng_add:
+  path: 'examples/dbtng_example/add'
+  defaults:
+    _title: 'Add Entry'
+    _form: '\Drupal\dbtng_example\DBTNGExampleAddForm'
+  requirements:
+    _permission: 'access content'
+
+dbtng_update:
+  path: 'examples/dbtng_example/update'
+  defaults:
+    _title: 'Update Entry'
+    _form: '\Drupal\dbtng_example\DBTNGExampleUpdateForm'
+  requirements:
+    _permission: 'access content'
+
+dbtng_advanced:
+  path: 'examples/dbtng_example/advanced'
+  defaults:
+    _title: 'Advanced List'
+    _controller: '\Drupal\dbtng_example\DBTNGExampleController::entryAdvancedList'
+  requirements:
+    _permission: 'access content'

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\dbtng_example\DBTNExampleAddForm
+ */
+
+namespace Drupal\dbtng_example;
+
+use Drupal\Core\Form\FormBase;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Simple form to add an entry, with all the interesting fields.
+ */
+class DBTNGExampleAddForm extends FormBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormID() {
+    return 'dbtng_add_form';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    $form = array();
+
+    $form['message'] = array(
+      '#markup' => $this->t('Add an entry to the dbtng_example table.'),
+    );
+
+    $form['add'] = array(
+      '#type' => 'fieldset',
+      '#title' => t('Add a person entry'),
+    );
+    $form['add']['name'] = array(
+      '#type' => 'textfield',
+      '#title' => t('Name'),
+      '#size' => 15,
+    );
+    $form['add']['surname'] = array(
+      '#type' => 'textfield',
+      '#title' => t('Surname'),
+      '#size' => 15,
+    );
+    $form['add']['age'] = array(
+      '#type' => 'textfield',
+      '#title' => t('Age'),
+      '#size' => 5,
+      '#description' => t("Values greater than 127 will cause an exception. Try it - it's a great example why exception handling is needed with DTBNG."),
+    );
+    $form['add']['submit'] = array(
+      '#type' => 'submit',
+      '#value' => t('Add'),
+    );
+
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validateForm(array &$form, FormStateInterface $form_state) {
+    // Confirm that age is numeric.
+    if (!intval($form_state->getValue('age'))) {
+      $form_state->setErrorByName('age', $this->t('Age needs to be a number'));
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    // Gather the current user so the new record has ownership.
+    $account = \Drupal::currentUser();
+    // Save the submitted entry.
+    $entry = array(
+      'name' => $form_state->getValue('name'),
+      'surname' => $form_state->getValue('surname'),
+      'age' => $form_state->getValue('age'),
+      'uid' => $account->id(),
+    );
+    $return = DBTNGExampleStorage::insert($entry);
+    if ($return) {
+      drupal_set_message(t('Created entry @entry', array('@entry' => print_r($entry, TRUE))));
+    }
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\dbtng_example\DBTNGExampleController.
+ */
+
+namespace Drupal\dbtng_example;
+
+use Drupal\Core\Controller\ControllerBase;
+
+/**
+ * Controller for DBTNG Example.
+ */
+class DBTNGExampleController extends ControllerBase {
+
+  /**
+   * Render a list of entries in the database.
+   */
+  public function entryList() {
+    $content = array();
+
+    $content['message'] = array(
+      '#markup' => $this->t('Generate a list of all entries in the database. There is no filter in the query.'),
+    );
+
+    $rows = array();
+    $headers = array(t('Id'), t('uid'), t('Name'), t('Surname'), t('Age'));
+
+    foreach ($entries = DBTNGExampleStorage::load() as $entry) {
+      // Sanitize each entry.
+      $rows[] = array_map('Drupal\Component\Utility\SafeMarkup::checkPlain', (array) $entry);
+    }
+    $content['table'] = array(
+      '#type' => 'table',
+      '#header' => $headers,
+      '#rows' => $rows,
+      '#empty' => t('No entries available.'),
+    );
+    // Don't cache this page.
+    $content['#cache']['max-age'] = 0;
+
+    return $content;
+  }
+
+  /**
+   * Render a filtered list of entries in the database.
+   */
+  public function entryAdvancedList() {
+    $content = array();
+
+    $content['message'] = array(
+      '#markup' => $this->t('A more complex list of entries in the database.') . ' ' .
+      $this->t('Only the entries with name = "John" and age older than 18 years are shown, the username of the person who created the entry is also shown.'),
+    );
+
+    $headers = array(
+      t('Id'),
+      t('Created by'),
+      t('Name'),
+      t('Surname'),
+      t('Age'),
+    );
+
+    $rows = array();
+    foreach ($entries = DBTNGExampleStorage::advancedLoad() as $entry) {
+      // Sanitize each entry.
+      $rows[] = array_map('Drupal\Component\Utility\SafeMarkup::checkPlain', $entry);
+    }
+    $content['table'] = array(
+      '#type' => 'table',
+      '#header' => $headers,
+      '#rows' => $rows,
+      '#attributes' => array('id' => 'dbtng-example-advanced-list'),
+      '#empty' => t('No entries available.'),
+    );
+    // Don't cache this page.
+    $content['#cache']['max-age'] = 0;
+    return $content;
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\dbtng_example\DBTNGExampleStorage
+ */
+
+namespace Drupal\dbtng_example;
+
+class DBTNGExampleStorage {
+
+  /**
+   * Save an entry in the database.
+   *
+   * The underlying DBTNG function is db_insert().
+   *
+   * Exception handling is shown in this example. It could be simplified
+   * without the try/catch blocks, but since an insert will throw an exception
+   * and terminate your application if the exception is not handled, it is best
+   * to employ try/catch.
+   *
+   * @param array $entry
+   *   An array containing all the fields of the database record.
+   *
+   * @return int
+   *   The number of updated rows.
+   *
+   * @throws \Exception
+   *   When the database insert fails.
+   *
+   * @see db_insert()
+   */
+  public static function insert($entry) {
+    $return_value = NULL;
+    try {
+      $return_value = db_insert('dbtng_example')
+          ->fields($entry)
+          ->execute();
+    }
+    catch (\Exception $e) {
+      drupal_set_message(t('db_insert failed. Message = %message, query= %query', array(
+            '%message' => $e->getMessage(),
+            '%query' => $e->query_string,
+          )), 'error');
+    }
+    return $return_value;
+  }
+
+  /**
+   * Update an entry in the database.
+   *
+   * @param array $entry
+   *   An array containing all the fields of the item to be updated.
+   *
+   * @return int
+   *   The number of updated rows.
+   *
+   * @see db_update()
+   */
+  public static function update($entry) {
+    try {
+      // db_update()...->execute() returns the number of rows updated.
+      $count = db_update('dbtng_example')
+          ->fields($entry)
+          ->condition('pid', $entry['pid'])
+          ->execute();
+    }
+    catch (\Exception $e) {
+      drupal_set_message(t('db_update failed. Message = %message, query= %query', array(
+            '%message' => $e->getMessage(),
+            '%query' => $e->query_string,
+          )), 'error');
+    }
+    return $count;
+  }
+
+  /**
+   * Delete an entry from the database.
+   *
+   * @param array $entry
+   *   An array containing at least the person identifier 'pid' element of the
+   *   entry to delete.
+   *
+   * @see db_delete()
+   */
+  public static function delete($entry) {
+    db_delete('dbtng_example')
+        ->condition('pid', $entry['pid'])
+        ->execute();
+  }
+
+  /**
+   * Read from the database using a filter array.
+   *
+   * The standard function to perform reads was db_query(), and for static
+   * queries, it still is.
+   *
+   * db_query() used an SQL query with placeholders and arguments as parameters.
+   *
+   * Drupal DBTNG provides an abstracted interface that will work with a wide
+   * variety of database engines.
+   *
+   * db_query() is deprecated except when doing a static query. The following is
+   * perfectly acceptable in Drupal 8. See
+   * @link http://drupal.org/node/310072 the handbook page on static queries @endlink
+   *
+   * @code
+   *   // SELECT * FROM {dbtng_example} WHERE uid = 0 AND name = 'John'
+   *   db_query(
+   *     "SELECT * FROM {dbtng_example} WHERE uid = :uid and name = :name",
+   *     array(':uid' => 0, ':name' => 'John')
+   *   )->execute();
+   * @endcode
+   *
+   * But for more dynamic queries, Drupal provides the db_select()
+   * API method, so there are several ways to perform the same SQL query. See
+   * the
+   * @link http://drupal.org/node/310075 handbook page on dynamic queries. @endlink
+   *
+   * @code
+   *   // SELECT * FROM {dbtng_example} WHERE uid = 0 AND name = 'John'
+   *   db_select('dbtng_example')
+   *     ->fields('dbtng_example')
+   *     ->condition('uid', 0)
+   *     ->condition('name', 'John')
+   *     ->execute();
+   * @endcode
+   *
+   * Here is db_select with named placeholders:
+   * @code
+   *   // SELECT * FROM {dbtng_example} WHERE uid = 0 AND name = 'John'
+   *   $arguments = array(':name' => 'John', ':uid' => 0);
+   *   db_select('dbtng_example')
+   *     ->fields('dbtng_example')
+   *     ->where('uid = :uid AND name = :name', $arguments)
+   *     ->execute();
+   * @endcode
+   *
+   * Conditions are stacked and evaluated as AND and OR depending on the type of
+   * query. For more information, read the conditional queries handbook page at:
+   * http://drupal.org/node/310086
+   *
+   * The condition argument is an 'equal' evaluation by default, but this can be
+   * altered:
+   * @code
+   *   // SELECT * FROM {dbtng_example} WHERE age > 18
+   *   db_select('dbtng_example')
+   *     ->fields('dbtng_example')
+   *     ->condition('age', 18, '>')
+   *     ->execute();
+   * @endcode
+   *
+   * @param array $entry
+   *   An array containing all the fields used to search the entries in the
+   *   table.
+   *
+   * @return object
+   *   An object containing the loaded entries if found.
+   *
+   * @see db_select()
+   * @see db_query()
+   * @see http://drupal.org/node/310072
+   * @see http://drupal.org/node/310075
+   */
+  public static function load($entry = array()) {
+    // Read all fields from the dbtng_example table.
+    $select = db_select('dbtng_example', 'example');
+    $select->fields('example');
+
+    // Add each field and value as a condition to this query.
+    foreach ($entry as $field => $value) {
+      $select->condition($field, $value);
+    }
+    // Return the result in object format.
+    return $select->execute()->fetchAll();
+  }
+
+  /**
+   * Load dbtng_example records joined with user records.
+   *
+   * DBTNG also helps processing queries that return several rows, providing the
+   * found objects in the same query execution call.
+   *
+   * This function queries the database using a JOIN between users table and the
+   * example entries, to provide the username that created the entry, and
+   * creates a table with the results, processing each row.
+   *
+   * SELECT
+   *  e.pid as pid, e.name as name, e.surname as surname, e.age as age
+   *  u.name as username
+   * FROM
+   *  {dbtng_example} e
+   * JOIN
+   *  users u ON e.uid = u.uid
+   * WHERE
+   *  e.name = 'John' AND e.age > 18
+   *
+   * @see db_select()
+   * @see http://drupal.org/node/310075
+   */
+  public static function advancedLoad() {
+    $select = db_select('dbtng_example', 'e');
+    // Join the users table, so we can get the entry creator's username.
+    $select->join('users_field_data', 'u', 'e.uid = u.uid');
+    // Select these specific fields for the output.
+    $select->addField('e', 'pid');
+    $select->addField('u', 'name', 'username');
+    $select->addField('e', 'name');
+    $select->addField('e', 'surname');
+    $select->addField('e', 'age');
+    // Filter only persons named "John".
+    $select->condition('e.name', 'John');
+    // Filter only persons older than 18 years.
+    $select->condition('e.age', 18, '>');
+    // Make sure we only get items 0-49, for scalability reasons.
+    $select->range(0, 50);
+
+    $entries = $select->execute()->fetchAll(\PDO::FETCH_ASSOC);
+
+    return $entries;
+  }
+
+}

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\dbtng_example\DBTNGExampleUpdateForm
+ */
+
+namespace Drupal\dbtng_example;
+
+use Drupal\Core\Form\FormBase;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Sample UI to update a record.
+ */
+class DBTNGExampleUpdateForm extends FormBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormID() {
+    return 'dbtng_update_form';
+  }
+
+  /**
+   * Sample UI to update a record.
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    // Wrap the form in a div.
+    $form = array(
+      '#prefix' => '<div id="updateform">',
+      '#suffix' => '</div>',
+    );
+    // Add some explanatory text to the form.
+    $form['message'] = array(
+      '#markup' => $this->t('Demonstrates a database update operation.'),
+    );
+    // Query for items to display.
+    $entries = DBTNGExampleStorage::load();
+    // Tell the user if there is nothing to display.
+    if (empty($entries)) {
+      $form['no_values'] = array(
+        '#value' => t('No entries exist in the table dbtng_example table.'),
+      );
+      return $form;
+    }
+
+    $keyed_entries = array();
+    foreach ($entries as $entry) {
+      $options[$entry->pid] = t('@pid: @name @surname (@age)', array(
+        '@pid' => $entry->pid,
+        '@name' => $entry->name,
+        '@surname' => $entry->surname,
+        '@age' => $entry->age,
+        )
+      );
+      $keyed_entries[$entry->pid] = $entry;
+    }
+
+    // Grab the pid.
+    $pid = $form_state->getValue('pid');
+    // Use the pid to set the default entry for updating.
+    $default_entry = !empty($pid) ? $keyed_entries[$pid] : $entries[0];
+
+    // Save the entries into the $form_state. We do this so the AJAX callback
+    // doesn't need to repeat the query.
+    $form_state->setValue('entries', $keyed_entries);
+
+    $form['pid'] = array(
+      '#type' => 'select',
+      '#options' => $options,
+      '#title' => t('Choose entry to update'),
+      '#default_value' => $default_entry->pid,
+      '#ajax' => array(
+        'wrapper' => 'updateform',
+        'callback' => array($this, 'updateCallback'),
+      ),
+    );
+
+    $form['name'] = array(
+      '#type' => 'textfield',
+      '#title' => t('Updated first name'),
+      '#size' => 15,
+      '#default_value' => $default_entry->name,
+    );
+
+    $form['surname'] = array(
+      '#type' => 'textfield',
+      '#title' => t('Updated last name'),
+      '#size' => 15,
+      '#default_value' => $default_entry->surname,
+    );
+    $form['age'] = array(
+      '#type' => 'textfield',
+      '#title' => t('Updated age'),
+      '#size' => 4,
+      '#default_value' => $default_entry->age,
+      '#description' => t('Values greater than 127 will cause an exception'),
+    );
+
+    $form['submit'] = array(
+      '#type' => 'submit',
+      '#value' => t('Update'),
+    );
+    return $form;
+  }
+
+  /**
+   * AJAX callback handler for the pid select.
+   *
+   * When the pid changes, populates the defaults from the database in the form.
+   */
+  public function updateCallback(array $form, FormStateInterface $form_state) {
+    // Gather the DB results from $form_state.
+    $entries = $form_state->getValue('entries');
+    // Use the specific entry for this $form_state.
+    $entry = $entries[$form_state->getValue('pid')];
+    // Setting the #value of items is the only way I was able to figure out
+    // to get replaced defaults on these items. #default_value will not do it
+    // and shouldn't.
+    foreach (array('name', 'surname', 'age') as $item) {
+      $form[$item]['#value'] = $entry->$item;
+    }
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validateForm(array &$form, FormStateInterface $form_state) {
+    // Confirm that age is numeric.
+    if (!intval($form_state->getValue('age'))) {
+      $form_state->setErrorByName('age', t('Age needs to be a number'));
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    // Gather the current user so the new record has ownership.
+    $account = \Drupal::currentUser();
+    // Save the submitted entry.
+    $entry = array(
+      'pid' => $form_state->getValue('pid'),
+      'name' => $form_state->getValue('name'),
+      'surname' => $form_state->getValue('surname'),
+      'age' => $form_state->getValue('age'),
+      'uid' => $account->id(),
+    );
+    $count = DBTNGExampleStorage::update($entry);
+    drupal_set_message(t('Updated entry @entry (@count row updated)', array(
+      '@count' => $count,
+      '@entry' => print_r($entry, TRUE),
+        )
+    ));
+  }
+
+}