text:
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ash/arc/instance_throttle/arc_instance_throttle.h"

#include <memory>
#include <string>
#include <vector>

#include "ash/components/arc/arc_features.h"
#include "ash/components/arc/arc_prefs.h"
#include "ash/components/arc/mojom/power.mojom.h"
#include "ash/components/arc/power/arc_power_bridge.h"
#include "ash/components/arc/session/arc_bridge_service.h"
#include "ash/components/arc/session/arc_service_manager.h"
#include "ash/components/arc/test/arc_util_test_support.h"
#include "ash/components/arc/test/connection_holder_util.h"
#include "ash/components/arc/test/fake_arc_session.h"
#include "ash/components/arc/test/fake_power_instance.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "chrome/browser/ash/arc/boot_phase_monitor/arc_boot_phase_monitor_bridge.h"
#include "chrome/browser/ash/arc/session/arc_session_manager.h"
#include "chrome/browser/ash/arc/test/test_arc_session_manager.h"
#include "chrome/browser/ash/throttle_observer.h"
#include "chrome/test/base/testing_profile.h"
#include "chromeos/dbus/concierge/concierge_client.h"
#include "chromeos/dbus/dbus_thread_manager.h"
#include "chromeos/dbus/power/power_manager_client.h"
#include "components/sync_preferences/testing_pref_service_syncable.h"
#include "content/public/test/browser_task_environment.h"
#include "services/device/public/cpp/test/test_wake_lock_provider.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace arc {

class ArcInstanceThrottleTest : public testing::Test {
 public:
  ArcInstanceThrottleTest() = default;
  ~ArcInstanceThrottleTest() override = default;

  ArcInstanceThrottleTest(const ArcInstanceThrottleTest&) = delete;
  ArcInstanceThrottleTest& operator=(const ArcInstanceThrottleTest&) = delete;

  void SetUp() override {
    chromeos::PowerManagerClient::InitializeFake();
    // Need to initialize DBusThreadManager before ArcSessionManager's
    // constructor calls DBusThreadManager::Get().
    chromeos::DBusThreadManager::Initialize();
    chromeos::ConciergeClient::InitializeFake(/*fake_cicerone_client=*/nullptr);
    arc_service_manager_ = std::make_unique<ArcServiceManager>();
    arc_session_manager_ =
        CreateTestArcSessionManager(std::make_unique<ArcSessionRunner>(
            base::BindRepeating(FakeArcSession::Create)));
    testing_profile_ = std::make_unique<TestingProfile>();

    SetArcAvailableCommandLineForTesting(
        base::CommandLine::ForCurrentProcess());

    ArcBootPhaseMonitorBridge::GetForBrowserContextForTesting(
        testing_profile_.get());
    arc_instance_throttle_ =
        ArcInstanceThrottle::GetForBrowserContextForTesting(
            testing_profile_.get());
    arc_instance_throttle_->set_delegate_for_testing(
        std::make_unique<TestDelegateImpl>(this));
  }

  void TearDown() override {
    DestroyPowerInstance();

    testing_profile_.reset();
    arc_session_manager_.reset();
    arc_service_manager_.reset();
    chromeos::ConciergeClient::Shutdown();
    chromeos::DBusThreadManager::Shutdown();
    chromeos::PowerManagerClient::Shutdown();
  }

 protected:
  void CreatePowerInstance() {
    ArcPowerBridge* const power_bridge =
        ArcPowerBridge::GetForBrowserContextForTesting(testing_profile_.get());
    DCHECK(power_bridge);

    power_instance_ = std::make_unique<FakePowerInstance>();
    arc_bridge_service()->power()->SetInstance(power_instance_.get());
    WaitForInstanceReady(arc_bridge_service()->power());
  }

  void DestroyPowerInstance() {
    if (!power_instance_)
      return;
    arc_bridge_service()->power()->CloseInstance(power_instance_.get());
    power_instance_.reset();
  }

  sync_preferences::TestingPrefServiceSyncable* GetPrefs() {
    return testing_profile_->GetTestingPrefService();
  }

  ArcBridgeService* arc_bridge_service() {
    return arc_service_manager_->arc_bridge_service();
  }

  ArcInstanceThrottle* arc_instance_throttle() {
    return arc_instance_throttle_;
  }

  FakePowerInstance* power_instance() { return power_instance_.get(); }

  size_t disable_cpu_restriction_counter() const {
    return disable_cpu_restriction_counter_;
  }

  size_t enable_cpu_restriction_counter() const {
    return enable_cpu_restriction_counter_;
  }

 private:
  class TestDelegateImpl : public ArcInstanceThrottle::Delegate {
   public:
    explicit TestDelegateImpl(ArcInstanceThrottleTest* test) : test_(test) {}
    ~TestDelegateImpl() override = default;

    TestDelegateImpl(const TestDelegateImpl&) = delete;
    TestDelegateImpl& operator=(const TestDelegateImpl&) = delete;

    void SetCpuRestriction(CpuRestrictionState cpu_restriction_state) override {
      switch (cpu_restriction_state) {
        case CpuRestrictionState::CPU_RESTRICTION_FOREGROUND:
          ++(test_->disable_cpu_restriction_counter_);
          break;
        case CpuRestrictionState::CPU_RESTRICTION_BACKGROUND:
          ++(test_->enable_cpu_restriction_counter_);
          break;
      }
    }

    void RecordCpuRestrictionDisabledUMA(const std::string& observer_name,
                                         base::TimeDelta delta) override {}

    ArcInstanceThrottleTest* test_;
  };

  content::BrowserTaskEnvironment task_environment_;
  std::unique_ptr<ArcServiceManager> arc_service_manager_;
  std::unique_ptr<ArcSessionManager> arc_session_manager_;
  std::unique_ptr<TestingProfile> testing_profile_;
  std::unique_ptr<FakePowerInstance> power_instance_;
  ArcInstanceThrottle* arc_instance_throttle_;
  size_t disable_cpu_restriction_counter_ = 0;
  size_t enable_cpu_restriction_counter_ = 0;
};

// Tests that ArcInstanceThrottle can be constructed and destructed.

TEST_F(ArcInstanceThrottleTest, TestConstructDestruct) {}

// Tests that ArcInstanceThrottle adjusts ARC CPU restriction
// when ThrottleInstance is called.
TEST_F(ArcInstanceThrottleTest, TestThrottleInstance) {
  arc_instance_throttle()->set_level_for_testing(
      ash::ThrottleObserver::PriorityLevel::LOW);
  EXPECT_EQ(1U, enable_cpu_restriction_counter());
  EXPECT_EQ(0U, disable_cpu_restriction_counter());

  // ArcInstanceThrottle level is already LOW, expect no change
  arc_instance_throttle()->set_level_for_testing(
      ash::ThrottleObserver::PriorityLevel::LOW);
  EXPECT_EQ(1U, enable_cpu_restriction_counter());
  EXPECT_EQ(0U, disable_cpu_restriction_counter());

  arc_instance_throttle()->set_level_for_testing(
      ash::ThrottleObserver::PriorityLevel::CRITICAL);
  EXPECT_EQ(1U, enable_cpu_restriction_counter());
  EXPECT_EQ(1U, disable_cpu_restriction_counter());

  arc_instance_throttle()->set_level_for_testing(
      ash::ThrottleObserver::PriorityLevel::LOW);
  EXPECT_EQ(2U, enable_cpu_restriction_counter());
  EXPECT_EQ(1U, disable_cpu_restriction_counter());
}

// Tests that power instance is correctly notified.
TEST_F(ArcInstanceThrottleTest, TestPowerNotificationEnabledByDefault) {
  // Set power instance and it should be automatically notified once connection
  // is made.
  CreatePowerInstance();
  EXPECT_EQ(1, power_instance()->cpu_restriction_state_count());
  EXPECT_EQ(mojom::CpuRestrictionState::CPU_RESTRICTION_BACKGROUND,
            power_instance()->last_cpu_restriction_state());

  arc_instance_throttle()->set_level_for_testing(
      ash::ThrottleObserver::PriorityLevel::CRITICAL);
  EXPECT_EQ(2, power_instance()->cpu_restriction_state_count());
  EXPECT_EQ(mojom::CpuRestrictionState::CPU_RESTRICTION_FOREGROUND,
            power_instance()->last_cpu_restriction_state());

  arc_instance_throttle()->set_level_for_testing(
      ash::ThrottleObserver::PriorityLevel::LOW);
  EXPECT_EQ(3, power_instance()->cpu_restriction_state_count());
  EXPECT_EQ(mojom::CpuRestrictionState::CPU_RESTRICTION_BACKGROUND,
            power_instance()->last_cpu_restriction_state());
}

// Tests that power instance notification is off by default.
TEST_F(ArcInstanceThrottleTest, TestPowerNotificationDisabled) {
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures({},
                                       {arc::kEnableThrottlingNotification});
  // Set power instance and it should be automatically notified once connection
  // is made.
  CreatePowerInstance();
  arc_instance_throttle()->set_level_for_testing(
      ash::ThrottleObserver::PriorityLevel::CRITICAL);
  arc_instance_throttle()->set_level_for_testing(
      ash::ThrottleObserver::PriorityLevel::LOW);
  EXPECT_EQ(0, power_instance()->cpu_restriction_state_count());
}

}  // namespace arc


text:
using System;
using System.Linq;
using System.Management;

namespace SRFS.IO {

    public class Partition {

        public Partition(Drive d, ManagementObject m) {
            _drive = d;
            _managementObject = m;
        }

        public uint Index {
            get {
                if (!_index.HasValue) _index = (uint)_managementObject["Index"];
                return _index.Value;
            }
        }

        public int BytesPerBlock {
            get {
                if (!_bytesPerBlock.HasValue) _bytesPerBlock = (int)((ulong)_managementObject.Properties["BlockSize"].Value);
                return _bytesPerBlock.Value;
            }
        }

        public long SizeBytes {
            get {
                if (!_sizeBytes.HasValue) _sizeBytes = (long)((UInt64)_managementObject.Properties["Size"].Value);
                return _sizeBytes.Value;
            }
        }

        public long StartingOffset {
            get {
                if (!_startingOffset.HasValue) _startingOffset = (long)((UInt64)_managementObject.Properties["StartingOffset"].Value);
                return _startingOffset.Value;
            }
        }

        public string DeviceID {
            get {
                if (_deviceID == null) _deviceID = (string)(_managementObject.Properties["DeviceID"].Value);
                return _deviceID;
            }
        }

        public Drive Drive => _drive;

        public string LogicalDriveLetter {
            get {
                if (_logicalDriveLetter == null) _logicalDriveLetter =
                        string.Join(", ", from l in _managementObject.GetRelated("Win32_LogicalDisk").Cast<ManagementBaseObject>() select l["Name"]);
                return _logicalDriveLetter;
            }
        }

        public void Refresh() {
            _bytesPerBlock = null;
            _sizeBytes = null;
            _startingOffset = null;
            _deviceID = null;
            _index = null;
            _logicalDriveLetter = null;
        }

        private readonly ManagementObject _managementObject;
        private readonly Drive _drive;

        private int? _bytesPerBlock;
        private long? _sizeBytes;
        private long? _startingOffset;
        private string _deviceID;
        private uint? _index;
        private string _logicalDriveLetter;
    }
}

redpajama_set_name: RedPajamaGithub


text:
package org.jeasy.random.beans;

public enum Gender {
    MALE, FEMALE
}


text:
<?php
/**
 * This class encapsulates a file. Convenience methods are made availible to simplify file
 * handling, such as directly reading the contents of the file or moving it to another
 * location.
 */
class File {
	/**
	 * Absolute path to the file.
	 * @var string
	 */
	protected $filename;

	/**
	 * Creates an instance representing the file specified.
	 *
	 * @param string $filename	Path to the file to represent.
	 */
	public function __construct ($filename) {
		$this->filename = $filename;
	}

    /**
     * Deletes the file.
     *
     * @return bool TRUE if successful, FALSE upon failure.
     */
    public function delete () {
        if (is_writable($this->getName())) {
            return unlink($this->getName());
        }
        return false;
    }

	/**
	 * Reads and returns the contents of this file as a string.
	 *
	 * @return string	Contents of this file.
	 */
	public function read () {
		return file_get_contents($this->filename);
	}

	/**
	 * Writes content to this file. Default is to overwrite the existing file content, but
	 * appending is also supported.
	 *
	 * @param string $content The new content.
	 * @param boolean $append Specifies if new content should be appended instead of
	 *                        overwriting the old. Default to FALSE, meaning all
	 *                        content is replaced.
	 * @return int            Bytes written, or FALSE on errors.
	 */
	public function write ($content, $append = false) {
		$mode = ($append ? 'a' : 'w');

		if (($f = fopen($this->filename, $mode)) !== false) {
			$written = fwrite($f, $content);
			fclose($f);

			return $written;
		}

		return false;
	}

	/**
	 * Returns the full name of this file.
	 *
	 * @return string	Name of file.
	 */
	public function getName () {
		return $this->filename;
	}

	/**
	 * Returns the MIME type of this file. The type is determined by the Fileinfo module if
	 * enabled, or else through the OS file utility on non-Windows systems.
	 *
	 * @return string	MIME type of file.
	 */
	public function getType () {
		if (class_exists('finfo', false)) {
			$finfo = new finfo(FILEINFO_MIME);
			$mime = $finfo->file($this->filename);
		}
		else if (strtoupper(substr(PHP_OS, 0, 3)) != 'WIN') {
			$mime = trim(exec('file --brief --mime ' . escapeshellarg($this->filename)));
		}

		if ($mime !== false) {
			$parts = explode(';', $mime);
			return $parts[0];
		}
		return false;
	}

	/**
	 * Returns the size of this file in bytes.
	 *
	 * @return string	Size of file (bytes).
	 */
	public function getSize () {
		return filesize($this->filename);
	}

	/**
	 * Attempts to move this file from its current location to another. $to can
	 * either be a directory path in which case the file will be named as the original file,
	 * or a full path including file name.
	 *
	 * @param string $to Path to new location.
	 * @return bool      TRUE on success, FALSE on failure.
	 */
	public function move ($to, $keepOriginal = false) {
		if (is_dir($to)) {
			$to = $this->appendFilenameToPath($to, basename($this->filename));
		}
		$method = ($keepOriginal === true ? 'copy' : 'rename');

		// Update current filename (path) if the move was successful
		if ($status = $method($this->filename, $to)) {
			$this->filename = $to;
		}

		return $status;
	}

	/**
	 * Attempts to copy this file from its current location to another. Works like
	 * File::move() except it retains the original file at its current location as well.
	 *
	 * @param string $to Path to new location.
	 * @return bool      TRUE on success, FALSE on failure.
	 */
	public function copy ($to) {
		return $this->move($to, true);
	}

	/**
	 * Appends $file onto the full $path, taking care to make sure
	 * the path ends with a slash before appending the file name.
	 *
	 * @param string $path Base path.
	 * @param string $file File to append onto $path.
	 * @return string      The path with file name appended.
	 */
	protected function appendFilenameToPath ($path, $file) {
		if (substr($path, strlen($path) - 1) == '/') {
			$path = $path . $file;
		}
		else {
			$path = $path . '/' . $file;
		}
		return $path;
	}
}
?>


text:
{% load staticfiles i18n %}

{% load commonrepo_tags %}

<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>Common Repository | {% block title %}Home{% endblock title %}</title>

    <meta content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" name="viewport">
    <meta name="description" content="Common Repository provides a free repostitory service for ELOs.">
    <meta name="author" content="edX PDR Lab at National Central University, Taiwan">

    {% block google_site %}

    <meta name="google-site-verification" content="{% get_settings_value "GOOGLE_SITE_VERIFICATION" %}" />
    {% endblock google_site %}

    {% block opengraph %}
    <meta property="og:site_name" content="Common Repository" />
    <meta property="og:title" content="{% block og_title %}None{% endblock og_title %}" />
    <meta property="og:type" content="{% block og_type %}website{% endblock og_type %}" />
    <meta property="og:url" content="{% block og_url %}None{% endblock og_url %}" />
    <meta property="og:image" content="{% block og_image %}None{% endblock og_image %}" />
    <meta property="og:description" content="{% block og_description %}None{% endblock og_description %}" />
    {% endblock opengraph %}

    {% block icons %}
    <link rel="apple-touch-icon" sizes="57x57" href="{% static 'images/icons/apple-icon-57x57.png' %}">
    <link rel="apple-touch-icon" sizes="60x60" href="{% static 'images/icons/apple-icon-60x60.png' %}">
    <link rel="apple-touch-icon" sizes="72x72" href="{% static 'images/icons/apple-icon-72x72.png' %}">
    <link rel="apple-touch-icon" sizes="76x76" href="{% static 'images/icons/apple-icon-76x76.png' %}">
    <link rel="apple-touch-icon" sizes="114x114" href="{% static 'images/icons/apple-icon-114x114.png' %}">
    <link rel="apple-touch-icon" sizes="120x120" href="{% static 'images/icons/apple-icon-120x120.png' %}">
    <link rel="apple-touch-icon" sizes="144x144" href="{% static 'images/icons/apple-icon-144x144.png' %}">
    <link rel="apple-touch-icon" sizes="152x152" href="{% static 'images/icons/apple-icon-152x152.png' %}">
    <link rel="apple-touch-icon" sizes="180x180" href="{% static 'images/icons/apple-icon-180x180.png' %}">
    <link rel="icon" type="image/png' %}" sizes="192x192"  href="{% static 'images/icons/android-icon-192x192.png' %}">
    <link rel="icon" type="image/png' %}" sizes="32x32" href="{% static 'images/icons/favicon-32x32.png' %}">
    <link rel="icon" type="image/png' %}" sizes="96x96" href="{% static 'images/icons/favicon-96x96.png' %}">
    <link rel="icon" type="image/png' %}" sizes="16x16" href="{% static 'images/icons/favicon-16x16.png' %}">
    <link rel="manifest" href="{% static 'images/icons/manifest.json' %}">
    <meta name="msapplication-TileColor" content="#ffffff">
    <meta name="msapplication-TileImage" content="{% static 'images/icons/ms-icon-144x144.png' %}">
    <meta name="theme-color" content="#ffffff">
    {% endblock icons %}

    {% block css %}

    <link rel="stylesheet" href="{% static "bootstrap/css/bootstrap.min.css" %}">

    <link rel="stylesheet" href="{% static "font-awesome/css/font-awesome.min.css" %}">

    <link rel="stylesheet" href="{% static "ionicons/css/ionicons.min.css" %}">

    <link rel="stylesheet" href="{% static "AdminLTE/css/AdminLTE.min.css" %}">
    <link rel="stylesheet" href="{% static "AdminLTE/css/skins/skin-black.min.css" %}">
    {% endblock css %}

    {% block google_analytics %}

    {% endblock google_analytics %}

    {% block angular %}

    {% endblock %}

            Toggle navigation

              {% block navbar_notifications %}
              {% if request.user.is_authenticated %}
                {% include "widgets/menu-notification.html" %}
              {% endif %}
              {% endblock navbar_notifications %}

              {% block navbar_user %}
              {% include "widgets/menu-user.html" %}
              {% endblock navbar_user %}

      {% block sidebar_main %}
      {% if request.user.is_authenticated %}
        {% include "widgets/sidebar-main.html" %}
      {% else %}
        {% include "widgets/sidebar-default.html" %}
      {% endif%}
      {% endblock sidebar_main %}

            {% block page_title %}{% endblock page_title %}
            {% block page_description %}{% endblock page_description %}

 Home

{% block page_breadcrumb %}{% endblock page_breadcrumb %}

          {% if messages %}
            {% for message in messages %}

                {# close-href is used because href is used by bootstrap to closing other divs #}
                ×
                {{ message }}

            {% endfor %}
          {% endif %}

          {% block content %}

Use this document as a way to quick start any new project.

          {% endblock content %}

      {% include "widgets/footer.html" %}

    {% block javascript %}

    {% endblock javascript %}
    {% block javascript_extra %}
    {% endblock javascript_extra %}


text:
<?php

namespace Orchestra\Asset;

use Illuminate\Contracts\Container\Container;
use Illuminate\Contracts\Support\DeferrableProvider;
use Illuminate\Support\ServiceProvider;

class AssetServiceProvider extends ServiceProvider implements DeferrableProvider
{
    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->registerResolver();

        $this->registerDispatcher();

        $this->registerAsset();
    }

    /**
     * Register the service provider.
     */
    protected function registerAsset(): void
    {
        $this->app->singleton('orchestra.asset', static function (Container $app) {
            return new Factory($app->make('orchestra.asset.dispatcher'));
        });
    }

    /**
     * Register the service provider.
     */
    protected function registerDispatcher(): void
    {
        $this->app->singleton('orchestra.asset.dispatcher', static function ($app) {
            return new Dispatcher(
                $app->make('files'),
                $app->make('html'),
                $app->make('orchestra.asset.resolver'),
                $app->publicPath()
            );
        });
    }

    /**
     * Register the service provider.
     */
    protected function registerResolver(): void
    {
        $this->app->singleton('orchestra.asset.resolver', static function () {
            return new DependencyResolver();
        });
    }

    /**
     * Get the services provided by the provider.
     *
     * @return array
     */
    public function provides()
    {
        return ['orchestra.asset', 'orchestra.asset.dispatcher', 'orchestra.asset.resolver'];
    }
}


text:
<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Cache;

class PostFeedController extends Controller
{
    /**
     * Show the rss feed of posts.
     */
    public function index(): Response
    {
        $posts = Cache::remember('feed-posts', now()->addHour(), fn () => Post::latest()->limit(20)->get());

        return response()->view('posts_feed.index', [
            'posts' => $posts
        ], 200)->header('Content-Type', 'text/xml');
    }
}


text:
package net.adamcin.oakpal.core;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;

import javax.jcr.nodetype.NodeTypeManager;

import org.junit.Before;
import org.junit.Test;

public class CNDURLInstallerTest {

    private URL cndAUrl;
    private URL cndBUrl;
    private URL cndCUrl;
    private URL cndDUrl;
    private URL cndEUrl;
    private URL cndFUrl;
    private URL cndYUrl;
    private URL cndZUrl;

    @Before
    public void setUp() throws Exception {
        File cndAFile = new File("src/test/resources/CNDURLInstallerTest/a.cnd");
        cndAUrl = cndAFile.toURI().toURL();
        File cndBFile = new File("src/test/resources/CNDURLInstallerTest/b.cnd");
        cndBUrl = cndBFile.toURI().toURL();
        File cndCFile = new File("src/test/resources/CNDURLInstallerTest/c.cnd");
        cndCUrl = cndCFile.toURI().toURL();
        File cndDFile = new File("src/test/resources/CNDURLInstallerTest/d.cnd");
        cndDUrl = cndDFile.toURI().toURL();
        File cndEFile = new File("src/test/resources/CNDURLInstallerTest/e.cnd");
        cndEUrl = cndEFile.toURI().toURL();
        File cndFFile = new File("src/test/resources/CNDURLInstallerTest/f.cnd");
        cndFUrl = cndFFile.toURI().toURL();
        File cndYFile = new File("src/test/resources/CNDURLInstallerTest/y.cnd");
        cndYUrl = cndYFile.toURI().toURL();
        File cndZFile = new File("src/test/resources/CNDURLInstallerTest/z.cnd");
        cndZUrl = cndZFile.toURI().toURL();
    }

    @Test
    public void testConstructor() {
        final CNDURLInstaller installerNulls = new CNDURLInstaller(null,
                Collections.emptyList(), null);
    }

    @Test
    public void testRegister() throws Exception {
        final DefaultErrorListener errorListener = new DefaultErrorListener();
        final CNDURLInstaller installer = new CNDURLInstaller(errorListener,
                Arrays.asList(cndFUrl, cndEUrl, cndDUrl, cndCUrl, cndBUrl, cndAUrl),
                Arrays.asList(cndYUrl, cndZUrl));

        new OakMachine.Builder().build().adminInitAndInspect(session -> {
            installer.register(session);
            NodeTypeManager ntManager = session.getWorkspace().getNodeTypeManager();
            assertTrue("has a:primaryType", ntManager.hasNodeType("a:primaryType"));
            assertTrue("has b:primaryType", ntManager.hasNodeType("b:primaryType"));
            assertTrue("has c:primaryType", ntManager.hasNodeType("c:primaryType"));
            assertTrue("has d:primaryType", ntManager.hasNodeType("d:primaryType"));
            assertTrue("has e:primaryType", ntManager.hasNodeType("e:primaryType"));
            assertFalse("does not have f:primaryType", ntManager.hasNodeType("f:primaryType"));
            assertFalse("does not have y:primaryType", ntManager.hasNodeType("y:primaryType"));
            assertTrue("has z:primaryType", ntManager.hasNodeType("z:primaryType"));
        });
        assertEquals("f and y should report errors: " + errorListener.getReportedViolations(), 2,
                errorListener.getReportedViolations().size());
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>allure-core</artifactId>
        <groupId>ru.yandex.qatools.allure</groupId>
        <version>1.5.3-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <name>Allure Report Face</name>
    <artifactId>allure-report-face</artifactId>
    <packaging>war</packaging>

    <properties>
        <sonar.language>js</sonar.language>
        <sonar.sources>src/</sonar.sources>
        <sonar.tests>test/</sonar.tests>
        <sonar.dynamicAnalysis>reuseReports</sonar.dynamicAnalysis>
        <sonar.exclusions>node_modules/**</sonar.exclusions>
        <sonar.tests.exclusions>node_modules/**</sonar.tests.exclusions>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
            </plugin>
        </plugins>
    </build>

    <profiles>
        <profile>
            <id>call-npm</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-war-plugin</artifactId>
                        <version>2.4</version>
                        <configuration>
                            <warSourceDirectory>target/allure-report</warSourceDirectory>
                            <failOnMissingWebXml>false</failOnMissingWebXml>
                        </configuration>
                    </plugin>
                    <plugin>
                        <groupId>com.github.eirslett</groupId>
                        <artifactId>frontend-maven-plugin</artifactId>
                        <version>0.0.27</version>
                        <executions>
                            <execution>
                                <id>install node and npm</id>
                                <goals>
                                    <goal>install-node-and-npm</goal>
                                </goals>
                                <configuration>
                                    <nodeVersion>v5.0.0</nodeVersion>
                                    <npmVersion>3.5.1</npmVersion>
                                </configuration>
                            </execution>
                            <execution>
                                <id>npm-install</id>
                                <goals>
                                    <goal>npm</goal>
                                </goals>
                                <configuration>
                                    <arguments>install</arguments>
                                </configuration>
                            </execution>
                            <execution>
                                <id>npm-build</id>
                                <goals>
                                    <goal>npm</goal>
                                </goals>
                                <configuration>
                                    <arguments>run build</arguments>
                                </configuration>
                            </execution>
                            <execution>
                                <id>npm-test</id>
                                <goals>
                                    <goal>npm</goal>
                                </goals>
                                <configuration>
                                    <arguments>test</arguments>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <profile>
            <id>dev</id>
            <properties>
                <allure.results.directory>${project.build.directory}/allure-results</allure.results.directory>
                <allure.report.directory>${project.build.directory}/allure-report</allure.report.directory>
                <allure.issues.tracker.pattern>http://github.com/allure-framework/allure-core/issues/%s
                </allure.issues.tracker.pattern>
                <allure.tests.management.pattern>http://github.com/allure-framework/allure-core/tests/%s
                </allure.tests.management.pattern>
            </properties>

            <dependencies>
                <dependency>
                    <groupId>ru.yandex.qatools.allure</groupId>
                    <artifactId>allure-report-data</artifactId>
                </dependency>
            </dependencies>

            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-resources-plugin</artifactId>
                        <executions>
                            <execution>
                                <id>copy-allure-model-test-resources</id>
                                <phase>compile</phase>
                                <goals>
                                    <goal>copy-resources</goal>
                                </goals>
                                <configuration>
                                    <outputDirectory>${allure.results.directory}</outputDirectory>
                                    <resources>
                                        <resource>
                                            <directory>
                                                ${project.parent.basedir}/allure-model/src/test/resources/allure-results
                                            </directory>
                                            <filtering>false</filtering>
                                        </resource>
                                    </resources>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>exec-maven-plugin</artifactId>
                        <executions>
                            <execution>
                                <phase>compile</phase>
                                <goals>
                                    <goal>java</goal>
                                </goals>
                            </execution>
                        </executions>
                        <configuration>
                            <mainClass>ru.yandex.qatools.allure.data.DummyReportGenerator</mainClass>
                            <arguments>
                                <argument>${allure.results.directory}</argument>
                                <argument>${allure.report.directory}</argument>
                            </arguments>
                            <systemProperties>
                                <property>
                                    <key>allure.issues.tracker.pattern</key>
                                    <value>${allure.issues.tracker.pattern}</value>
                                </property>
                                <property>
                                    <key>allure.tests.management.pattern</key>
                                    <value>${allure.tests.management.pattern}</value>
                                </property>
                            </systemProperties>
                            <additionalClasspathElements>
                                <classpathElement>
                                    ${settings.localRepository}/org/slf4j/slf4j-simple/1.7.12/slf4j-simple-1.7.12.jar
                                </classpathElement>
                            </additionalClasspathElements>
                        </configuration>
                        <dependencies>
                            <dependency>
                                <groupId>org.slf4j</groupId>
                                <artifactId>slf4j-simple</artifactId>
                                <version>1.7.12</version>
                            </dependency>
                        </dependencies>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>

</project>


text:
int main(int argc, char** argv) {
  // Suppress unused variable warnings
  (void) argc;
  (void) argv;

  FILE* fp = fopen("/dev/urandom", "r");
  rappor::UnixKernelRand irr_rand(fp);

  rappor::Deps deps(rappor::Md5, "client-secret", rappor::HmacSha256,
                    irr_rand);
  rappor::Params params(32,    // num_bits (k)
                        2,     // num_hashes (h)
                        128,   // num_cohorts (m)
                        0.25,  // probability f for PRR
                        0.75,  // probability p for IRR
                        0.5);  // probability q for IRR

  const char* encoder_id = "metric-name";
  rappor::Encoder encoder(encoder_id, params, deps);

  // Now use it to encode values.  The 'out' value can be sent over the
  // network.
  rappor::Bits out;
  assert(encoder.EncodeString("foo", &out));  // returns false on error
  printf("'foo' encoded with RAPPOR: %0x, cohort %d\n", out, encoder.cohort());

  // Raw bits
  assert(encoder.EncodeBits(0x123, &out));  // returns false on error
  printf("0x123 encoded with RAPPOR: %0x, cohort %d\n", out, encoder.cohort());
}


text:
namespace NetFusion.Rest.Docs.Core.Descriptions
{
    /// <summary>
    /// Marker interface identifying a class responsible for adding additional
    /// documentation to a REST Api action method document.  For example, comments
    /// stored within .NET code XML files can be queried and added to the model.
    /// </summary>
    public interface IDocDescription
    {

    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>

	<Titre>
De la maintenance générale à la topo-maintenance</Titre>
	<Auteurs>
		<Auteur ID="roccogerard-00028">
			<Nom>ROCCO</Nom>
			<Prenom>Gérard</Prenom>
		</Auteur>
	</Auteurs>
	<Niveau1>
		<Titre>
Les missions de la maintenance</Titre>

Les responsabilités du service maintenance sont les suivantes.

		<Inter>
Conservation du potentiel de production</Inter>
		<Liste Type="tiret">
			<Item>

Disponibilité permanente ;

			</Item>
			<Item>

rendement optimum des investissements.

			</Item>
		</Liste>

Ceci implique un diagnostic permanent, la réparation si nécessaire, la réalisation d'installations et d'aménagements de l'outil de production.

		<Inter>
Exploitation de l'infrastructure technique</Inter>
		<Liste Type="tiret">
			<Item>

Fourniture d'énergie ;

			</Item>
			<Item>

distribution des fluides.

			</Item>
		</Liste>

Ceci implique la recherche d'économies d'énergie.

		<Inter>
Respect de l'environnement</Inter>
		<Liste Type="tiret">
			<Item>

Lutte contre les nuisances ;

			</Item>
			<Item>

évacuation des déchets ;

			</Item>
			<Item>

traitement des eaux usées.

			</Item>
		</Liste>

Ceci implique la connaissance de la législation en vigueur.

		<Inter>
Sécurité</Inter>
		<Liste Type="tiret">
			<Item>

Bon état général de marche ;

			</Item>
			<Item>

bon état des dispositifs de sécurité ;

			</Item>
			<Item>

adaptation des équipements en fonction des risques ;

			</Item>
			<Item>

encadrement et/ou exécution des travaux d'installation de nouveaux équipements ;

			</Item>
			<Item>

maintenance des centrales, réseaux et circuits de distribution des énergies et des fluides.

			</Item>
		</Liste>

Ceci implique la connaissance des textes légaux et des exigences internes pour la protection du personnel contre les accidents.

Toutes ces actions nécessitent une organisation et des outils adaptés :

		<Liste Type="tiret">
			<Item>

préparer les travaux et développer des méthodes d'intervention efficaces ;

			</Item>
			<Item>

établir et mettre en œuvre les programmes de maintenance, mais aussi enregistrer et analyser les travaux préventifs réalisés ;

			</Item>
			<Item>

gérer un portefeuille de travaux, ce qui comprend en particulier le traitement des demandes, ainsi que les actions de planification et de lancement des opérations de maintenance ;

			</Item>
			<Item>

gérer des stocks de pièces détachées ;

			</Item>
			<Item>

approvisionner les pièces de rechange et la matière, si on est amené à fabriquer soi-même certaines pièces ;

			</Item>
			<Item>

organiser le service maintenance, bureau et atelier ;

			</Item>
			<Item>

s'équiper avec les outillages nécessaires et les entretenir ;

			</Item>
			<Item>

gérer la documentation technique ;

			</Item>
			<Item>

gérer le personnel et le former aux nouveaux matériels et technologies ;

			</Item>
			<Item>

sélectionner de bons fournisseurs et sous-traitants et les évaluer en permanence ;

			</Item>
			<Item>

mettre en place des indicateurs de suivi pour mesurer l'efficacité du service, du point de vue technique et financier.

			</Item>
		</Liste>
	</Niveau1>
	<Niveau1>
		<Titre>
Les différents types de maintenance</Titre>

On distingue plusieurs orientations pour la maintenance :

		<Liste Type="tiret">
			<Item>

la maintenance des équipements de production, qui doit assurer une disponibilité maximale de l'outil pour éviter les baisses de productivité ;

			</Item>
			<Item>

la maintenance et le suivi réglementaire des engins et matériels de manutention ;

			</Item>
			<Item>

la maintenance des infrastructures, bâtiments et abords des sites de production ;

			</Item>
			<Item>

la maintenance des réseaux (fluides), à savoir air comprimé, eau, électricité ;

			</Item>
			<Item>

la maintenance informatique appliquée au <Ital>hardware</Ital>, <Ital>software</Ital>, à l'informatique industrielle et à l'informatique de gestion.

			</Item>
		</Liste>
	</Niveau1>
	<Niveau1>
		<Titre>
La fonction maintenance</Titre>

Traditionnellement, la maintenance est assurée par un service maintenance, autonome pour sa gestion <AppelFig>
				<TxtAvt>(<Ital>cf.</Ital>
				</TxtAvt>
				<Appel IDRef="fig-V-100-210_3-1"/>
				<TxtApr>)</TxtApr>
			</AppelFig>.

			<Image file="V-100-210_3-1.png"/>
			<Titre>
Organisation d'une maintenance centralisée</Titre>

Cette structure assure des prestations réalisées dans le cadre d'une « relation client-fournisseur interne », avec des exigences de qualité de prestation, coût, délai et service (essentiellement la disponibilité).

En conséquence, les fonctions du service maintenance doivent être parfaitement définies, de même que les moyens de mesure de son efficacité et les objectifs définis en amont.

Quelques exemples d'objectifs du service maintenance :

		<Liste Type="tiret">
			<Item>

réduire le nombre de pannes et les coûts induits par ces pannes ;

			</Item>
			<Item>

améliorer l'outil de production et les infrastructures en les adaptant aux besoins, pour limiter les risques et gagner en productivité ;

			</Item>
			<Item>

respecter la législation en matière de sécurité et environnement.

			</Item>
		</Liste>

Depuis les années 1980, la tendance a été à la décentralisation, à la dissolution des structures centralisées de maintenance et à leur intégration au sein des différents services utilisateurs :

		<Liste Type="tiret">
			<Item>

en externalisant les prestations de maintenance vers des sous-traitants de confiance, ayant une grande notion du service ;

			</Item>
			<Item>

en ne conservant en interne que le personnel nécessaire aux petits travaux quotidiens de surveillance (niveaux, graissages, petits dépannages), dépendant hiérarchiquement du responsable du service ou atelier pour lequel ils opèrent ;

			</Item>
			<Item>

en faisant ponctuellement appel à des experts internes ou externes lorsque cela s'avère -nécessaire.

			</Item>
		</Liste>

Cette tendance est due à plusieurs facteurs :

		<Liste Type="tiret">
			<Item>

la réduction régulière des budgets de maintenance depuis les années 1960 ;

			</Item>
			<Item>

l'arrivée de nouvelles technologies, qui ont développé les techniques prédictives au détriment du remplacement systématique préventif ;

			</Item>
			<Item>

la tendance à rendre le personnel plus autonome (autocontrôle, automaintenance), à le responsabiliser sur l'entretien de ses équipements, la surveillance, les graissages, les réparations mineures, dans les limites de ses compétences.

			</Item>
		</Liste>

Aujourd'hui, les tâches de maintenance sont souvent transférées aux structures de production, avec une structure spécifiquement chargée de la planification des travaux de maintenance <AppelFig>
				<TxtAvt>(<Ital>cf.</Ital>
				</TxtAvt>
				<Appel IDRef="fig-V-100-210_3-2"/>
				<TxtApr>)</TxtApr>
			</AppelFig>.

			<Image file="V-100-210_3-2.png"/>
			<Titre>
Organisation de la maintenance intégrée à la production</Titre>

Les tâches de maintenance courante sont transférées au personnel de production, avec éventuellement l'assistance d'un technicien de maintenance :

		<Liste Type="tiret">
			<Item>

surveillance régulière des niveaux ;

			</Item>
			<Item>

réalisation des graissages, réglages et du nettoyage ;

			</Item>
			<Item>

réparations mineures.

			</Item>
		</Liste>

Ceci implique une formation adéquate du personnel concerné et des moyens adaptés, notamment en matière de détection et d'analyse prédictive.

Les interventions plus lourdes sont sous-traitées dans le cadre d'un contrat de prestation de service avec des sociétés spécialisées.

Dans cette organisation, de nouvelles attributions ou nouvelles fonctions voient le jour, comme la planification des interventions et la prévision des ressources humaines et matérielles nécessaires aux opérations de maintenance :

		<Liste Type="tiret">
			<Item>

sélection, suivi et évaluation des fournisseurs et sous-traitants ;

			</Item>
			<Item>

établissement de cahiers des charges, et administration des commandes et ordres de prestation aux prestataires de maintenance ;

			</Item>
			<Item>

contrôle et réception des travaux sous-traités.

			</Item>
		</Liste>

Et encore, le suivi et l'analyse des historiques d'intervention sur la durée de vie des équipements :

		<Liste Type="tiret">
			<Item>

fiabilisation des interventions ;

			</Item>
			<Item>

renouvellement des équipements ou organes ;

			</Item>
			<Item>

gestion des stocks pièces détachées ;

			</Item>
			<Item>

diminution des coûts de maintenance en optimisant les fréquences de suivi et d'intervention.

			</Item>
		</Liste>

Ces tâches sont réalisées par une structure composée de techniciens généralistes de bon niveau qui vont :

		<Liste Type="tiret">
			<Item>

planifier les interventions ;

			</Item>
			<Item>

assister le personnel de production ;

			</Item>
			<Item>

établir les cahiers des charges de sous-traitance ;

			</Item>
			<Item>

superviser les interventions des sous-traitants ;

			</Item>
			<Item>

analyser l'historique des interventions par équipement.

			</Item>
		</Liste>

Il y a donc deux voies parallèles qui se dessinent dans la décentralisation de la maintenance :

		<Liste Type="tiret">
			<Item>

la promotion de la maintenance de premier niveau en interne ;

			</Item>
			<Item>

le pilotage de la maintenance externalisée.

			</Item>
		</Liste>

La mise en œuvre des politiques de maintenance dans les années 1990 fait émerger plusieurs méthodes différentes, mais elles convergent toutes vers l'automaintenance et l'appel à la sous-traitance :

		<Liste Type="tiret">
			<Item>

la maintenance productive totale (TPM), qui préconise que chaque personne de l'entreprise soit une personne de maintenance, avec pour objectif le zéro panne ;

			</Item>
			<Item>

l'assurance capacité de production <Abrev IDRefAbrev="acp-00403">
(ACP)</Abrev>, qui vise la disponibilité maximale de l'outil de production, pour obtenir un rendement ciblé optimal ;

			</Item>
			<Item>

la maintenance base zéro (MBZ), qui vise à maintenir les équipements au meilleur prix, en englobant la conception des équipements en amont pour minimiser leurs risques de panne ;

			</Item>
			<Item>

la mise en place de contrats internes de maintenance (<Abrev IDRefAbrev="cim-00302 ">
(CIM)</Abrev>, établis dans le cadre de relations client-fournisseur internes définissant, à l'année, les modalités d'intervention répondant aux besoins du moment.

			</Item>
		</Liste>

Mais si toutes ces méthodes visent à minimiser le coût des équipements sur leur cycle de vie (<Ital>life cycle cost </Ital>ou LCC, en anglais), aucune ne constitue de solution universelle. Seule une analyse au cas par cas permet de trouver le bon équilibre en fonction de l'environnement interne et externe de l'entreprise.

	</Niveau1>
	<Niveau1>
		<Titre>
L'automaintenance et les concepts de la TPM</Titre>
		<Inter>
Les concepts de la TPM</Inter>

La maintenance productive totale (<Ital>Total Productive Maintenance</Ital>, TPM en anglais) nous vient du Japon, qui privilégie toujours la méthode participative par opposition à une culture qui privilégie l'aspect technique des choses.

Il convient de distinguer cette approche de la TPM, <Ital>Total Productive Management</Ital>, qui est plutôt une démarche d'amélioration continue.

La TPM dont il est fait mention ici a deux objectifs clés :

		<Liste Type="tiret">
			<Item>

stimuler l'intérêt du personnel dans son travail en lui donnant des tâches d'un niveau de difficulté supérieur (le sortir d'un travail de type « presse-bouton » ) ;

			</Item>
			<Item>

améliorer la productivité en augmentant les performances des machines, le rendement et la qualité des produits.

			</Item>
		</Liste>

Le principe de base en est que « Tout le personnel est potentiellement un homme ou femme de maintenance ».

Ceci implique d'améliorer en permanence les compétences de tout le personnel impliqué dans cette approche, avec des retombées dans les performances de l'entreprise à tous les niveaux <AppelFig>
				<TxtAvt>(<Ital>cf.</Ital>
				</TxtAvt>
				<Appel IDRef="fig-V-100-210_4-1"/>
				<TxtApr>)</TxtApr>
			</AppelFig>.

			<Image file="V-100-210_4-1.png"/>
			<Titre>
Les concepts de la TPM</Titre>

		<Inter>
Les activités principales de la TPM</Inter>

Pour réussir la mise en œuvre d'une TPM, il faut mettre en place une planification de la maintenance et prévoir les moyens nécessaires :

		<Liste Type="tiret">
			<Item>

surveillance et suivi des équipements ;

			</Item>
			<Item>

dotation en moyens matériels ;

			</Item>
			<Item>

mise à disposition des pièces détachées ;

			</Item>
			<Item>

documentation de travail.

			</Item>
		</Liste>

Il faut également former les acteurs concernés (opérateurs et agents de maintenance) et suivre l'amélioration de l'efficacité des équipements de production.

		<Inter>
Mise en œuvre de la TPM</Inter>

La mise en œuvre de la TPM comprend une phase de développement de la détection des dysfonctionnements et une phase de déploiement sur le terrain, avec notamment :

		<Liste Type="tiret">
			<Item>

la planification des activités de maintenance ;

			</Item>
			<Item>

la formation du personnel ;

			</Item>
			<Item>

l'enclenchement et le suivi des actions d'amélioration.

			</Item>
		</Liste>
		<Niveau4>
			<Titre>
La détection des dysfonctionnements</Titre>

Chaque opérateur doit pouvoir détecter simplement les incidents. Il doit également participer à la recherche des causes et de solutions par rapport aux problèmes rencontrés.

Ceci implique la mise en place de repères visuels de type indicateurs ou détrompeurs (poka yoke) : l'indication doit être immédiate et non équivoque, et permettre d'identifier le problème et son importance.

		</Niveau4>
		<Niveau4>
			<Titre>
Le déploiement sur le terrain</Titre>

Le déploiement dans les ateliers doit permettre de :

			<Liste Type="tiret">
				<Item>

prévoir les moyens, les actions systématiques de maintenance préventive et les actions conditionnelles, le suivi et l'analyse de toutes les interventions ;

				</Item>
				<Item>

rendre les opérateurs plus performants sur leurs machines grâce à une meilleure connaissance et à une meilleure compréhension de leur fonctionnement. Ceci s'obtient par une formation appropriée, qui prend en compte notamment les actions d'entretien courant ;

				</Item>
				<Item>

rendre les équipements plus fiables pour éviter que « TPM »  ne rime avec « dépannage ».

				</Item>
			</Liste>

C'est un travail qui peut durer plusieurs mois, voire plusieurs années, en fonction de la culture de l'entreprise et de la qualification du personnel.

La formation du personnel, qui constitue une grande partie du déploiement, doit être progressive pour ne pas heurter les mentalités et laisser le temps d'assimiler les nouvelles connaissances.

Comme en toute chose, il faut commencer par des tâches simples :

			<Liste Type="tiret">
				<Item>

vérifier les niveaux d'huile ;

				</Item>
				<Item>

faire les graissages ;

				</Item>
				<Item>

repérer les vis à resserrer ;

				</Item>
				<Item>

détecter les organes qui se détériorent et les réparer.

				</Item>
			</Liste>

Lorsque de telles opérations sont définies et réalisées couramment, elles feront l'objet d'instructions ou de modes opératoires d'entretien, spécifiques à chaque équipement. En alternative, on les consignera dans un support de formation au poste.

Ensuite, on peut compléter ces actions par une amélioration de la propreté au poste de travail, <Ital>via</Ital> une démarche 5 S, par exemple. Au terme de cette deuxième étape, on intègre les règles de propreté et de rangement à la documentation précitée.

Lorsque toutes ces actions sont devenues naturelles, il est possible d'augmenter progressivement la complexité des tâches prises en charge par l'opérateur :

			<Liste Type="tiret">
				<Item>

réalisation du diagnostic des installations, à l'aide de check-lists spécifiques ;

				</Item>
				<Item>

réparation à partir des constats de dysfonctionnement, suivant des instructions ou modes opératoires de réparation et/ou les documents du constructeur de la machine ;

				</Item>
				<Item>

alimentation et analyse des historiques de maintenance.

				</Item>
			</Liste>

Tout au long de ces étapes, il convient de développer des attitudes participatives du personnel, de lui apprendre à communiquer, à travailler en groupe, à analyser, à donner des idées, et faire prendre conscience du rôle moteur de chacun dans son environnement et vis-à-vis de ses -collègues.

Chaque acteur devient une force de propositions et participe ainsi à l'amélioration globale des performances de la société, avec des objectifs précis à atteindre à son niveau.

Il est fortement recommandé de développer, en parallèle à de telles démarches, des dispositifs de reconnaissance et d'évaluation de la satisfaction du personnel.

		</Niveau4>
	</Niveau1>


text:
namespace offline_pages {

// The reconcile task should be run at request coordinator startup to find any
// tasks that were offlining when chrome died, and change the state back to
// available.
class ReconcileTask : public Task {
 public:
  ReconcileTask(RequestQueueStore* store,
                RequestQueueStore::UpdateCallback callback);
  ~ReconcileTask() override;

 private:
  // TaskQueue::Task implementation:
  // Starts the async chain.
  void Run() override;

  // Step 1. Get results from the store.
  void GetRequests();

  // Step 2. Flip OFFLINING requests to AVAILABLE and put back in queue.
  void Reconcile(bool success,
                 std::vector<std::unique_ptr<SavePageRequest>> requests);

  // Step 3. Processes update result.
  void UpdateCompleted(UpdateRequestsResult update_result);

  // Member variables, all pointers are not owned here.
  raw_ptr<RequestQueueStore> store_;
  // Callback to complete the task.
  RequestQueueStore::UpdateCallback callback_;
  // Allows us to pass a weak pointer to callbacks.
  base::WeakPtrFactory<ReconcileTask> weak_ptr_factory_{this};
};

}  // namespace offline_pages

#endif  // COMPONENTS_OFFLINE_PAGES_CORE_BACKGROUND_RECONCILE_TASK_H_


text:
<?xml version="1.0" encoding="UTF-8"?>
<pmd-cpd>
<duplication lines="180" tokens="683">
<file line="171" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\application\FacesRequestProcessor.java"/>
<file line="185" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\application\FacesTilesRequestProcessor.java"/>
<codefragment>
<![CDATA[
    }

    // Override default processing to provide logging
    protected Action processActionCreate(HttpServletRequest request,
                                         HttpServletResponse response,
                                         ActionMapping mapping)
        throws IOException {

        if (log.isTraceEnabled()) {
            log.trace("Performing standard action create");
        }
        Action result = super.processActionCreate(request, response, mapping);
        if (log.isDebugEnabled()) {
            log.debug("Standard action create returned " +
                      result.getClass().getName() + " instance");
        }
        return (result);

    }

    // Override default processing to provide logging
    protected ActionForm processActionForm(HttpServletRequest request,
                                           HttpServletResponse response,
                                           ActionMapping mapping) {
        if (log.isTraceEnabled()) {
            log.trace("Performing standard action form processing");
            String attribute = mapping.getAttribute();
            if (attribute != null) {
                String name = mapping.getName();
                FormBeanConfig fbc = moduleConfig.findFormBeanConfig(name);
                if (fbc != null) {
                    if ("request".equals(mapping.getScope())) {
                        log.trace("  Bean in request scope = " +
                                  request.getAttribute(attribute));
                    } else {
                        log.trace("  Bean in session scope = " +
                                  request.getSession().getAttribute(attribute));
                    }
                } else {
                    log.trace("  No FormBeanConfig for '" + name + "'");
                }
            } else {
                log.trace("  No form bean for this action");
            }
        }
        ActionForm result =
            super.processActionForm(request, response, mapping);
        if (log.isDebugEnabled()) {
            log.debug("Standard action form returned " +
                      result);
        }
        return (result);

    }

    // Override default processing to provide logging
    protected ActionForward processActionPerform(HttpServletRequest request,
                                                 HttpServletResponse response,
                                                 Action action,
                                                 ActionForm form,
                                                 ActionMapping mapping)
        throws IOException, ServletException {

        if (log.isTraceEnabled()) {
            log.trace("Performing standard action perform");
        }
        ActionForward result =
            super.processActionPerform(request, response, action,
                                       form, mapping);
        if (log.isDebugEnabled()) {
            log.debug("Standard action perform returned " +
                      (result == null ? "NULL" :
                      result.getPath()) + " forward path");
        }
        return (result);

    }

    // Override default processing to provide logging
    protected boolean processForward(HttpServletRequest request,
                                     HttpServletResponse response,
                                     ActionMapping mapping)
        throws IOException, ServletException {

        if (log.isTraceEnabled()) {
            log.trace("Performing standard forward handling");
        }
        boolean result = super.processForward
            (request, response, mapping);
        if (log.isDebugEnabled()) {
            log.debug("Standard forward handling returned " + result);
        }
        return (result);

    }

    // Override default processing to provide logging
    protected void processForwardConfig(HttpServletRequest request,
                                        HttpServletResponse response,
                                        ForwardConfig forward)
        throws IOException, ServletException {

        if (log.isTraceEnabled()) {
            log.trace("Performing standard forward config handling");
        }
        super.processForwardConfig(request, response, forward);
        if (log.isDebugEnabled()) {
            log.debug("Standard forward config handling completed");
        }

    }

    // Override default processing to provide logging
    protected boolean processInclude(HttpServletRequest request,
                                     HttpServletResponse response,
                                     ActionMapping mapping)
        throws IOException, ServletException {

        if (log.isTraceEnabled()) {
            log.trace("Performing standard include handling");
        }
        boolean result = super.processInclude
            (request, response, mapping);
        if (log.isDebugEnabled()) {
            log.debug("Standard include handling returned " + result);
        }
        return (result);

    }

    /**
     *
Identify and return the path component (from the request URI for a
     * non-Faces request, or from the form event for a Faces request)
     * that we will use to select an ActionMapping to dispatch with.
     * If no such path can be identified, create an error response and return
     * null.

     *
     * @param request The servlet request we are processing
     * @param response The servlet response we are creating
     *
     * @exception IOException if an input/output error occurs
     */
    protected String processPath(HttpServletRequest request,
                                 HttpServletResponse response)
        throws IOException {

        // Are we processing a Faces request?
        ActionEvent event = (ActionEvent)
            request.getAttribute(Constants.ACTION_EVENT_KEY);

        // Handle non-Faces requests in the usual way
        if (event == null) {
            if (log.isTraceEnabled()) {
                log.trace("Performing standard processPath() processing");
            }
            return (super.processPath(request, response));
        }

        // Calculate the path from the form name
        UIComponent component = event.getComponent();
        if (log.isTraceEnabled()) {
            log.trace("Locating form parent for command component " +
                      event.getComponent());
        }
        while (!(component instanceof FormComponent)) {
            component = component.getParent();
            if (component == null) {
                log.warn("Command component was not nested in a Struts form!");
                return (null);
            }
        }
        if (log.isTraceEnabled()) {
]]>
</codefragment>
</duplication>
<duplication lines="119" tokens="410">
<file line="352" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\application\FacesRequestProcessor.java"/>
<file line="366" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\application\FacesTilesRequestProcessor.java"/>
<codefragment>
<![CDATA[
                      ((FormComponent) component).getAction());
        }
        return (((FormComponent) component).getAction());

    }

    /**
     *
Populate the properties of the specified ActionForm
     * instance from the request parameters included with this request,
     * IF this is a non-Faces request.  For a Faces request,
     * this will have already been done by the Update Model Values
     * phase of the request processing lifecycle, so all we have to do is
     * recognize whether the request was cancelled or not.

     *
     * @param request The servlet request we are processing
     * @param response The servlet response we are creating
     * @param form The ActionForm instance we are populating
     * @param mapping The ActionMapping we are using
     *
     * @exception ServletException if thrown by RequestUtils.populate()
     */
    protected void processPopulate(HttpServletRequest request,
                                   HttpServletResponse response,
                                   ActionForm form,
                                   ActionMapping mapping)
        throws ServletException {

        // Are we processing a Faces request?
        ActionEvent event = (ActionEvent)
            request.getAttribute(Constants.ACTION_EVENT_KEY);

        // Handle non-Faces requests in the usual way
        if (event == null) {
            if (log.isTraceEnabled()) {
                log.trace("Performing standard processPopulate() processing");
            }
            super.processPopulate(request, response, form, mapping);
            return;
        }

        // Faces Requests require no processing for form bean population
        // so we need only check for the cancellation command name
        if (log.isTraceEnabled()) {
            log.trace("Faces request, so no processPopulate() processing");
        }
        UIComponent source = event.getComponent();
        if (source instanceof UICommand) {
            if ("cancel".equals(((UICommand) source).getId())) {
                if (log.isTraceEnabled()) {
                    log.trace("Faces request with cancel button pressed");
                }
                request.setAttribute(Globals.CANCEL_KEY, Boolean.TRUE);
            }
        }

    }

    // Override default processing to provide logging
    protected boolean processValidate(HttpServletRequest request,
                                      HttpServletResponse response,
                                      ActionForm form,
                                      ActionMapping mapping)
        throws IOException, ServletException, InvalidCancelException {

        if (log.isTraceEnabled()) {
            log.trace("Performing standard validation");
        }
        boolean result = super.processValidate
            (request, response, form, mapping);
        if (log.isDebugEnabled()) {
            log.debug("Standard validation processing returned " + result);
        }
        return (result);

    }

    // --------------------------------------------------------- Private Methods

    /**
     *
Return the used Lifecycle ID (default or custom).

     */
    private String getLifecycleId()
    {
        String lifecycleId = this.servlet.getServletContext().getInitParameter(LIFECYCLE_ID_ATTR);
        return lifecycleId != null ? lifecycleId : LifecycleFactory.DEFAULT_LIFECYCLE;
    }

    /**
     *
Return true if the specified context-relative URI
     * specifies a request to be processed by the Struts controller servlet.

     *
     * @param uri URI to be checked
     */
    private boolean isStrutsRequest(String uri) {

        int question = uri.indexOf("?");
        if (question >= 0) {
            uri = uri.substring(0, question);
        }
        String mapping = (String)
            servlet.getServletContext().getAttribute(Globals.SERVLET_KEY);
        if (mapping == null) {
            return (false);
        } else if (mapping.startsWith("*.")) {
            return (uri.endsWith(mapping.substring(1)));
        } else if (mapping.endsWith("/*")) {
            return (uri.startsWith(mapping.substring(0, mapping.length() - 2)));
        } else {
            return (false);
        }

    }

}
]]>
</codefragment>
</duplication>
<duplication lines="102" tokens="368">
<file line="74" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\application\FacesRequestProcessor.java"/>
<file line="74" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\application\FacesTilesRequestProcessor.java"/>
<codefragment>
<![CDATA[
        LogFactory.getLog(FacesTilesRequestProcessor.class);

    /**
     *
The lifecycle id.

     */
    public static final String LIFECYCLE_ID_ATTR = "javax.faces.LIFECYCLE_ID";

    // ------------------------------------------------------- Protected Methods

    /**
     *
Set up a Faces Request if we are not already processing one.  Next,
     * create a new view if the specified uri is different from
     * the current view identifier.  Finally, cause the new view to be
     * rendered, and call FacesContext.responseComplete() to
     * indicate that this has already been done.

     *
     * @param uri Context-relative path to forward to
     * @param request Current page request
     * @param response Current page response
     *
     * @exception IOException if an input/output error occurs
     * @exception ServletException if a servlet error occurs
     */
    protected void doForward(String uri,
                             HttpServletRequest request,
                             HttpServletResponse response)
        throws IOException, ServletException {

        if (log.isDebugEnabled()) {
            log.debug("doForward(" + uri + ")");
        }

        // Remove the current ActionEvent (if any)
        request.removeAttribute(Constants.ACTION_EVENT_KEY);

        // Process a Struts controller request normally
        if (isStrutsRequest(uri)) {
            if (response.isCommitted()) {
                if (log.isTraceEnabled()) {
                    log.trace("  super.doInclude(" + uri + ")");
                }
                super.doInclude(uri, request, response);
            } else {
                if (log.isTraceEnabled()) {
                    log.trace("  super.doForward(" + uri + ")");
                }
                super.doForward(uri, request, response);
            }
            return;
        }

        // Create a FacesContext for this request if necessary
        LifecycleFactory lf = (LifecycleFactory)
            FactoryFinder.getFactory(FactoryFinder.LIFECYCLE_FACTORY);
        Lifecycle lifecycle =
            lf.getLifecycle(getLifecycleId());
        boolean created = false;
        FacesContext context = FacesContext.getCurrentInstance();
        if (context == null) {
            if (log.isTraceEnabled()) {
                log.trace("  Creating new FacesContext for '" + uri + "'");
            }
            created = true;
            FacesContextFactory fcf = (FacesContextFactory)
                FactoryFinder.getFactory(FactoryFinder.FACES_CONTEXT_FACTORY);
            context = fcf.getFacesContext(servlet.getServletContext(),
                                          request, response, lifecycle);
        }

        // Create a new view root
        ViewHandler vh = context.getApplication().getViewHandler();
        if (log.isTraceEnabled()) {
            log.trace("  Creating new view for '" + uri + "'");
        }
        context.setViewRoot(vh.createView(context, uri));

        // Cause the view to be rendered
        if (log.isTraceEnabled()) {
            log.trace("  Rendering view for '" + uri + "'");
        }
        try {
            lifecycle.render(context);
        } finally {
            if (created) {
                if (log.isTraceEnabled()) {
                    log.trace("  Releasing context for '" + uri + "'");
                }
                context.release();
            } else {
                if (log.isTraceEnabled()) {
                    log.trace("  Rendering completed");
                }
            }
        }

    }

    // Override default processing to provide logging
    protected void internalModuleRelativeForward
]]>
</codefragment>
</duplication>
<duplication lines="70" tokens="140">
<file line="185" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\component\MessageComponent.java"/>
<file line="119" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\component\WriteComponent.java"/>
<codefragment>
<![CDATA[
    }

    /**
     *
Return the CSS style(s) to be rendered for this component.

     */
    public String getStyle() {

        ValueBinding vb = getValueBinding("style");
        if (vb != null) {
            return (String) vb.getValue(getFacesContext());
        } else {
            return style;
        }

    }

    /**
     *
Set the CSS style(s) to be rendered for this component.

     *
     * @param style The new CSS style(s)
     */
    public void setStyle(String style) {

        this.style = style;

    }

    /**
     *
Return the CSS style class(es) to be rendered for this component.

     */
    public String getStyleClass() {

        ValueBinding vb = getValueBinding("styleClass");
        if (vb != null) {
            return (String) vb.getValue(getFacesContext());
        } else {
            return styleClass;
        }

    }

    /**
     *
Set the CSS style class(es) to be rendered for this component.

     *
     * @param styleClass The new CSS style class(es)
     */
    public void setStyleClass(String styleClass) {

        this.styleClass = styleClass;

    }

    // ---------------------------------------------------- StateManager Methods

    /**
     *
Restore the state of this component.

     *
     * @param context FacesContext for the current request
     * @param state State object from which to restore our state
     */
    public void restoreState(FacesContext context, Object state) {

        Object values[] = (Object[]) state;
        super.restoreState(context, values[0]);
]]>
</codefragment>
</duplication>
<duplication lines="61" tokens="109">
<file line="361" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\component\CommandLinkComponent.java"/>
<file line="267" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\component\FormComponent.java"/>
<codefragment>
<![CDATA[
    }

    /**
     *
Return the CSS style(s) to be rendered for this component.

     */
    public String getStyle() {

        ValueBinding vb = getValueBinding("style");
        if (vb != null) {
            return (String) vb.getValue(getFacesContext());
        } else {
            return style;
        }

    }

    /**
     *
Set the CSS style(s) to be rendered for this component.

     *
     * @param style The new CSS style(s)
     */
    public void setStyle(String style) {

        this.style = style;

    }

    /**
     *
Return the CSS style class(es) to be rendered for this component.

     */
    public String getStyleClass() {

        ValueBinding vb = getValueBinding("styleClass");
        if (vb != null) {
            return (String) vb.getValue(getFacesContext());
        } else {
            return styleClass;
        }

    }

    /**
     *
Set the CSS style class(es) to be rendered for this component.

     *
     * @param styleClass The new CSS style class(es)
     */
    public void setStyleClass(String styleClass) {

        this.styleClass = styleClass;

    }

    /**
     *
Return the target frame for the response to this form submit.

     */
    public String getTarget() {
]]>
</codefragment>
</duplication>
<duplication lines="67" tokens="108">
<file line="361" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\component\CommandLinkComponent.java"/>
<file line="185" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\component\MessageComponent.java"/>
<codefragment>
<![CDATA[
    }

    /**
     *
Return the CSS style(s) to be rendered for this component.

     */
    public String getStyle() {

        ValueBinding vb = getValueBinding("style");
        if (vb != null) {
            return (String) vb.getValue(getFacesContext());
        } else {
            return style;
        }

    }

    /**
     *
Set the CSS style(s) to be rendered for this component.

     *
     * @param style The new CSS style(s)
     */
    public void setStyle(String style) {

        this.style = style;

    }

    /**
     *
Return the CSS style class(es) to be rendered for this component.

     */
    public String getStyleClass() {

        ValueBinding vb = getValueBinding("styleClass");
        if (vb != null) {
            return (String) vb.getValue(getFacesContext());
        } else {
            return styleClass;
        }

    }

    /**
     *
Set the CSS style class(es) to be rendered for this component.

     *
     * @param styleClass The new CSS style class(es)
     */
    public void setStyleClass(String styleClass) {

        this.styleClass = styleClass;

    }

    // ---------------------------------------------------- StateManager Methods

    /**
     *
Restore the state of this component.

     *
     * @param context FacesContext for the current request
     * @param state State object from which to restore our state
     */
    public void restoreState(FacesContext context, Object state) {
]]>
</codefragment>
</duplication>
<duplication lines="28" tokens="108">
<file line="60" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\component\CommandLinkComponent.java"/>
<file line="51" path="C:\Workspace\STRUTS_1_3_BRANCH\faces\src\main\java\org\apache\struts\faces\taglib\CommandLinkTag.java"/>
<codefragment>
<![CDATA[
    private String immediate = null;
    private String lang = null;
    private String onblur = null;
    private String onclick = null;
    private String ondblclick = null;
    private String onfocus = null;
    private String onkeydown = null;
    private String onkeypress = null;
    private String onkeyup = null;
    private String onmousedown = null;
    private String onmousemove = null;
    private String onmouseout = null;
    private String onmouseover = null;
    private String onmouseup = null;
    private String rel = null;
    private String rev = null;
    private String style = null;
    private String styleClass = null;
    private String tabindex = null;
    private String target = null;
    private String title = null;
    private String type = null;

    // ---------------------------------------------------------- Tag Attributes

    public void setAccesskey(String accesskey) {
]]>
</codefragment>
</duplication>
</pmd-cpd>


text:
{% extends "layout_picker.html" %}

{% set serviceName = "Apply for a resident's parking permit" %}
{% set pageTitle = "Confirm your document" %}

{% block content %}

            This is the image you have uploaded

            By proceeding you confirm that this photo is of your v5 document.

          Confirm

{% endblock %}


text:
<mindtagger mode="precision">

  <template for="each-item">
    {{item.p1_text}} -- {{item.p2_text}}
    with expectation {{item.expectation | number:3}} appeared in:

        <big mindtagger-word-array="item.tokens" array-format="postgres">
            <mindtagger-highlight-words from="item.p1_start" to="item.p1_end" with-style="background-color: yellow;"/>
            <mindtagger-highlight-words from="item.p2_start" to="item.p2_end" with-style="background-color: cyan;"/>
        </big>

  </template>

  <template for="tags">

  </template>

</mindtagger>


text:
/**
 * Deletes the temp directory used in development tasks
 */
'use strict';

var gulp    = require('gulp');
var del     = require('del');
var config  = require('../config');

gulp.task('clean-dev', function (cb) {
    del(config.devTempDir, cb);
});