text:
<title>Results for browserNumb</title>
<link href="../testng.css" rel="stylesheet" type="text/css" />
<link href="../my-testng.css" rel="stylesheet" type="text/css" />

Results for
browserNumb

1 test
1 class
1 method:

  chronological

  alphabetical

  not run (0)

0 group
reporter output
testng.xml

theKnot (1/0/0)
  Results

redpajama_set_name: RedPajamaGithub


text:
package org.locationtech.geowave.test.services;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.locationtech.geowave.core.store.cli.store.DataStorePluginOptions;
import org.locationtech.geowave.service.client.AnalyticServiceClient;
import org.locationtech.geowave.test.GeoWaveITRunner;
import org.locationtech.geowave.test.TestUtils;
import org.locationtech.geowave.test.annotation.Environments;
import org.locationtech.geowave.test.annotation.Environments.Environment;
import org.locationtech.geowave.test.annotation.GeoWaveTestStore;
import org.locationtech.geowave.test.annotation.GeoWaveTestStore.GeoWaveStoreType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@RunWith(GeoWaveITRunner.class)
@Environments({Environment.SERVICES})
public class AnalyticIT {
  private static final Logger LOGGER = LoggerFactory.getLogger(AnalyticIT.class);
  private static final String WFS_URL_PREFIX =
      ServicesTestEnvironment.JETTY_BASE_URL + "/geoserver/wfs";

  private static final String GEOSTUFF_LAYER_FILE =
      "src/test/resources/wfs-requests/geostuff_layer.xml";
  private static final String INSERT_FILE = "src/test/resources/wfs-requests/insert.xml";
  private static final String LOCK_FILE = "src/test/resources/wfs-requests/lock.xml";
  private static final String QUERY_FILE = "src/test/resources/wfs-requests/query.xml";
  private static final String UPDATE_FILE = "src/test/resources/wfs-requests/update.xml";

  private AnalyticServiceClient analyticServiceClient;

  private String input_storename;
  private String output_storename;

  private static final String testName = "AnalyticIT";

  @GeoWaveTestStore(
      value = {
          GeoWaveStoreType.ACCUMULO,
          GeoWaveStoreType.BIGTABLE,
          GeoWaveStoreType.HBASE,
          GeoWaveStoreType.CASSANDRA,
          GeoWaveStoreType.DYNAMODB,
          GeoWaveStoreType.KUDU,
          GeoWaveStoreType.REDIS,
          GeoWaveStoreType.ROCKSDB,
          GeoWaveStoreType.FILESYSTEM})
  protected DataStorePluginOptions dataStoreOptions;

  private static long startMillis;

  @BeforeClass
  public static void startTimer() {
    startMillis = System.currentTimeMillis();
    TestUtils.printStartOfTest(LOGGER, testName);
  }

  @AfterClass
  public static void reportTest() {
    TestUtils.printEndOfTest(LOGGER, testName, startMillis);
  }

  @Before
  public void initialize() {
    // Perform ingest operations here, so there is data on which to run the
    // analytics.
  }

  @After
  public void cleanupWorkspace() {
    // Remove everything created in the @Before method, so each test starts
    // with a clean slate.

    // If confident the initialization data does not change during the test,
    // you may move the setup/tear down actions to the @BeforeClass and
    // @AfterClass methods.
  }

  @Test
  @Ignore
  public void example() {
    // Tests should contain calls to the REST services methods, checking
    // them for proper response and status codes.

    // Use this method to check:

    TestUtils.assertStatusCode(
        "Should Successfully <Insert Objective Here>",
        200,
        analyticServiceClient.kmeansSpark(input_storename, output_storename));
  }

  @Test
  @Ignore
  public void dbScan() {
    // TODO: Implement this test
  }

  @Test
  @Ignore
  public void kde() {
    // TODO: Implement this test
  }

  @Test
  @Ignore
  public void kmeansspark() {
    // TODO: Implement this test
  }

  @Test
  @Ignore
  public void nn() {
    // TODO: Implement this test
  }

  @Test
  @Ignore
  public void spatialjoin() {
    // TODO: Implement this test
  }

  @Test
  @Ignore
  public void sql() {
    // TODO: Implement this test
  }
}


text:
import React from 'react';
import PropTypes from 'prop-types';
import {connect} from 'react-redux';
import {injectIntl, intlShape, FormattedDate, FormattedMessage} from 'react-intl';

import Dialog from 'material-ui/Dialog';
import RaisedButton from 'material-ui/RaisedButton';
import DoneIcon from 'material-ui/svg-icons/action/done';

import getSortScore from '../../modules/getCategorySortScore';
import countVisitedLocationsInCategory from '../../modules/countVisitedLocationsInCategory';

import {builder, routes} from '../../modules/routes';

import {small} from '../../data/mongoDB/image/sizes';

import {navigateTo} from '../../redux/action/ui';

/**
 * format the visited locations for the profile
 * @param locations
 * @param visitedLocations
 * @returns {Array}
 */
const formatVisitedLocations = (locations, visitedLocations) => {
    return Object.keys(visitedLocations)
        .map((key) => {
            return {
                ...locations[key],
                id: key,
                dateTimeOfVisit: new Date(visitedLocations[key]),
            };
        })
        .sort((a, b) => {
            return a.dateTimeOfVisit - b.dateTimeOfVisit;
        })
        .map((element) => {
            return

                <FormattedDate value={element.dateTimeOfVisit} /> : {element.name} {element.originalUrl}

;
        });
};

/**
 * format the categories for the profile
 * @param categories
 * @param visitedLocations
 * @returns {Array}
 */
const formatCategories = (categories, visitedLocations) => {
    return Object.keys(categories)
        .map((key) => {
            return {
                name: categories[key].name,
                visited: countVisitedLocationsInCategory(categories[key].items, visitedLocations),
                total: categories[key].items.length,
            };
        })
        .sort((a, b) => {
            return getSortScore(a) - getSortScore(b);
        })
        .map((element) => {
            const done = (element.total === element.visited ? <DoneIcon /> : null);
            return
{element.name} ({element.visited} / {element.total}){done}
;
        });
};

/**
 * the profile dialog
 */
class DialogProfile extends React.Component {

    render () {
        const {formatMessage} = this.props.intl;
        const actions = [
            <RaisedButton
                label={formatMessage({id: 'dialog.profile.changePassword'})}
                primary={false}
                onTouchTap={this.props.onChangePasswordDialog}
            />,
            <RaisedButton
                label={formatMessage({id: 'dialog.close'})}
                primary
                onTouchTap={this.props.onCloseDialog}
            />,

        ];

        const formatedVisitedLocations = formatVisitedLocations(this.props.locations, this.props.visitedLocations);
        const formatedCategories = formatCategories(this.props.categories, this.props.visitedLocations);

        return (
            <Dialog
                title={formatMessage({id: 'dialog.profile.title'}, {userEmail: this.props.userEmail})}
                actions={actions}
                open
            >

                    {(this.props.hasImage ?  : null)}
                    <FormattedMessage id='dialog.profile.confirmed' />: {this.props.userEmailConfirmed
                    ? <DoneIcon /> : null}

                    <FormattedMessage id='dialog.profile.visitedLocations' />:

{formatedVisitedLocations}

                    <FormattedMessage id='dialog.profile.categories' />:

{formatedCategories}

            </Dialog>
        );
    }
}

DialogProfile.propTypes = {
    hasImage: PropTypes.bool,
    userEmail: PropTypes.string.isRequired,
    userEmailConfirmed: PropTypes.bool,
    locations: PropTypes.object.isRequired,
    categories: PropTypes.object.isRequired,
    visitedLocations: PropTypes.object.isRequired,

    onCloseDialog: PropTypes.func.isRequired,
    onChangePasswordDialog: PropTypes.func.isRequired,

    intl: intlShape.isRequired,
};

const mapStateToProps = (state) => {
    return {
        categories: state.data.categories,
        locations: state.data.locations,
        userEmail: state.session.user.email,
        hasImage: !!state.session.user.imageId,
        userEmailConfirmed: state.session.user.isConfirmed,
        visitedLocations: state.session.user.visited || {},
    };
};

const mapDispatchToProps = (dispatch) => {
    return {
        onChangePasswordDialog: () => dispatch(navigateTo(routes.user.passwordChange)),
        onCloseDialog: () => dispatch(navigateTo(routes.root)),
    };
};

export default connect(
    mapStateToProps,
    mapDispatchToProps
)(injectIntl(DialogProfile));


text:
// Type definitions for Swiper 4.2
// Project: https://github.com/nolimits4web/Swiper
// Definitions by: Sebastián Galiano <https://github.com/sgaliano>, Luca Trazzi <https://github.com/lucax88x>, Eugene Matseruk <https://github.com/ematseruk>, Luiz M. <https://github.com/odahcam>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.9

declare module 'swiper' {
    /**
     * Common Swiper events.
     */
    type CommonEvent =
        | 'init'
        | 'beforeDestroy'
        | 'slideChange'
        | 'slideChangeTransitionStart'
        | 'slideChangeTransitionEnd'
        | 'slideNextTransitionStart'
        | 'slideNextTransitionEnd'
        | 'slidePrevTransitionStart'
        | 'slidePrevTransitionEnd'
        | 'transitionStart'
        | 'transitionEnd'
        | 'touchStart'
        | 'touchMove'
        | 'touchMoveOpposite'
        | 'sliderMove'
        | 'touchEnd'
        | 'click'
        | 'tap'
        | 'doubleTap'
        | 'imagesReady'
        | 'progress'
        | 'reachBeginning'
        | 'reachEnd'
        | 'fromEdge'
        | 'setTranslate'
        | 'setTransition'
        | 'resize';

    /**
     * Swiper pagination event names.
     */
    type PaginationEvent = 'paginationRender' | 'paginationUpdate';

    /**
     * Swiper autoplay event names.
     */
    type AutoplayEvent = 'autoplayStart' | 'autoplayStop' | 'autoplay';

    /**
     * Swiper lazy-loading event names.
     */
    type LazyLoadingEvent = 'lazyImageLoad' | 'lazyImageReady';

    /**
     * Swiper event names.
     */
    type SwiperEvent = CommonEvent | PaginationEvent | AutoplayEvent | LazyLoadingEvent;

    /**
     * Swiper module types.
     */
    type SwiperModule =
        | Navigation
        | Pagination
        | Scrollbar
        | Autoplay
        | Parallax
        | Lazy
        | FadeEffect
        | CoverflowEffect
        | FlipEffect
        | CubeEffect
        | Zoom
        | Keyboard
        | Mousewheel
        | Virtual
        | HashNavigation
        | History
        | Controller
        | A11y;

    type DOM7Element = any;
    type SelectableElement = string | HTMLElement;

    /*
     * Swiper options and events.
     */

    /**
     * Main constructor options.
     */
    interface SwiperOptions {
        /**
         * Whether Swiper should be initialised automatically when you create an instance.
         * If disabled, then you need to init it manually by calling mySwiper.init()
         *
         * @default true
         */
        init?: boolean;

        /**
         * Index number of initial slide.
         *
         * @default 0
         */
        initialSlide?: number;

        /**
         * Could be 'horizontal' or 'vertical' (for vertical slider).
         *
         * @default 'horizontal'
         */
        direction?: 'horizontal' | 'vertical';

        /**
         * Duration of transition between slides (in ms)
         *
         * @default 300
         */
        speed?: number;

        /**
         * Enabled this option and plugin will set width/height on swiper wrapper equal to total size of all slides.
         * Mostly should be used as compatibility fallback option for browser that don't support flexbox layout well
         */
        setWrapperSize?: boolean;

        /**
         * Enabled this option and swiper will be operated as usual except it will not move, real translate values on wrapper will not be set.
         * Useful when you may need to create custom slide transition
         */
        virtualTranslate?: boolean;

        /**
         * Swiper width (in px). Parameter allows to force Swiper width.
         * Useful only if you initialize Swiper when it is hidden.
         *
         * @note Setting this parameter will make Swiper not responsive
         */
        width?: number;

        /**
         * Swiper height (in px). Parameter allows to force Swiper height.
         * Useful only if you initialize Swiper when it is hidden.
         *
         * @note Setting this parameter will make Swiper not responsive
         */
        height?: number;

        /**
         * Set to true and slider wrapper will adopt its height to the height of the currently active slide
         *
         * @default false
         */
        autoHeight?: boolean;

        /**
         * Set to true to round values of slides width and height to prevent blurry texts on usual
         * resolution screens (if you have such)
         *
         * @default false
         */
        roundLengths?: boolean;

        /**
         * Set to true on  Swiper for correct touch events interception. Use only on
         * swipers that use same direction as the parent one
         *
         * @default false
         */
        nested?: boolean;

        /**
         * If enabled (by default) and navigation elements' parameters passed as a string (like ".pagination")
         * then Swiper will look for such elements through child elements first.
         * Applies for pagination, prev/next buttons and scrollbar elements
         *
         * @default true
         */
        uniqueNavElements?: boolean;

        /**
         * Tranisition effect. Could be "slide", "fade", "cube", "coverflow" or "flip"
         *
         * @default 'slide'
         */
        effect?: 'slide' | 'fade' | 'cube' | 'coverflow' | 'flip';

        /**
         * Fire [Transition/SlideChange][Start/End] events on swiper initialization.
         * Such events will be fired on initialization in case of your initialSlide is not 0, or you use loop mode
         *
         * @default true
         */
        runCallbacksOnInit?: boolean;

        /**
         * When enabled Swiper will be disabled and hide navigation buttons on
         * case there are not enough slides for sliding.
         *
         * @default false
         */
        watchOverflow?: boolean;

        /**
         * Register event handlers.
         */
        on?: { [key in SwiperEvent]?: () => void };

        // Slides grid
        spaceBetween?: number;
        slidesPerView?: number | 'auto';
        slidesPerColumn?: number;
        slidesPerColumnFill?: 'row' | 'column';
        slidesPerGroup?: number;
        centeredSlides?: boolean;
        slidesOffsetBefore?: number;
        slidesOffsetAfter?: number;
        normalizeSlideIndex?: boolean;

        // Grab Cursor
        grabCursor?: boolean;

        // Touches
        // @TODO: verify next property
        touchEventsTarget?: 'container' | 'wrapper';
        touchRatio?: number;
        touchAngle?: number;
        simulateTouch?: boolean;
        shortSwipes?: boolean;
        longSwipes?: boolean;
        longSwipesRatio?: number;
        longSwipesMs?: number;
        followFinger?: boolean;
        allowTouchMove?: boolean;
        threshold?: number;
        touchMoveStopPropagation?: boolean;
        iOSEdgeSwipeDetection?: boolean;
        iOSEdgeSwipeThreshold?: number;
        touchReleaseOnEdges?: boolean;
        passiveListeners?: boolean;

        // Touch Resistance
        resistance?: boolean;
        resistanceRatio?: number;

        // Swiping / No swiping
        allowSlidePrev?: boolean;
        allowSlideNext?: boolean;
        noSwiping?: boolean;
        noSwipingClass?: string;
        // noSwipingSelector?: string;
        swipeHandler?: SelectableElement;

        // Clicks
        preventClicks?: boolean;
        preventClicksPropagation?: boolean;
        slideToClickedSlide?: boolean;

        // Freemode
        freeMode?: boolean;
        freeModeMomentum?: boolean;
        freeModeMomentumRatio?: number;
        freeModeMomentumVelocityRatio?: number;
        freeModeMomentumBounce?: boolean;
        freeModeMomentumBounceRatio?: number;
        freeModeMinimumVelocity?: number;
        freeModeSticky?: boolean;

        // Progress
        watchSlidesProgress?: boolean;
        watchSlidesVisibility?: boolean;

        // Images
        preloadImages?: boolean;
        updateOnImagesReady?: boolean;

        // Loop
        loop?: boolean;
        loopAdditionalSlides?: number;
        loopedSlides?: number;
        loopFillGroupWithBlank?: boolean;

        // Breakpoints
        breakpoints?: {
            [index: number]: SwiperOptions;
        };

        // Observer
        observer?: boolean;
        observeParents?: boolean;

        // Namespace
        containerModifierClass?: string;
        slideClass?: string;
        slideActiveClass?: string;
        slideDuplicatedActiveClass?: string;
        slideVisibleClass?: string;
        slideDuplicateClass?: string;
        slideNextClass?: string;
        slideDuplicatedNextClass?: string;
        slidePrevClass?: string;
        slideDuplicatedPrevClass?: string;
        wrapperClass?: string;

        // Components
        navigation?: NavigationOptions;
        pagination?: PaginationOptions;
        scrollbar?: ScrollbarOptions;
        autoplay?: AutoplayOptions | boolean;
        parallax?: boolean;
        lazy?: LazyOptions | boolean;
        fadeEffect?: FadeEffectOptions;
        coverflowEffect?: CoverflowEffectOptions;
        flipEffect?: FlipEffectOptions;
        cubeEffect?: CubeEffectOptions;
        zoom?: ZoomOptions | boolean;
        keyboard?: KeyboardOptions | boolean;
        mousewheel?: MousewheelOptions | boolean;
        virtual?: VirtualOptions | boolean;
        hashNavigation?: HashNavigationOptions | boolean;
        history?: HistoryNavigationOptions | boolean;
        a11y?: A11yOptions | boolean;
    }

    interface EventsOptions {
        /**
         * Fired right after Swiper initialization.
         * Note that with swiper.on('init') syntax it will
         * work only in case you set init: false parameter.
         *
         * @example
         * var swiper = new Swiper('.swiper-container', {
         *   init: false,
         *   // other parameters
         * });
         *
         * @example
         * swiper.on('init', function() {
         *  // do something
         * });
         *
         * @example
         * // init Swiper
         * swiper.init();
         *
         * @example
         * // Otherwise use it as the parameter:
         * var swiper = new Swiper('.swiper-container', {
         *   // other parameters
         *   on: {
         *     init: function () {
         *       // do something
         *     },
         *   }
         * });
         */
        init?: () => any;

        /**
         * Triggered right beforey Swiper destoryed
         */
        beforeDestroy?: () => any;

        /**
         * Triggered when currently active slide is changed
         */
        slideChange?: () => any;

        /**
         * Triggered in the beginning of animation to other slide (next or previous).
         */
        slideChangeTransitionStart?: () => any;

        /**
         * Triggered after animation to other slide (next or previous).
         */
        slideChangeTransitionEnd?: () => any;

        /**
         * Same as "slideChangeTransitionStart" but for "forward" direction only
         */
        slideNextTransitionStart?: () => any;

        /**
         * Same as "slideChangeTransitionEnd" but for "forward" direction only
         */
        slideNextTransitionEnd?: () => any;

        /**
         * Same as "slideChangeTransitionStart" but for "backward" direction only
         */
        slidePrevTransitionStart?: () => any;

        /**
         * Same as "slideChangeTransitionEnd" but for "backward" direction only
         */
        slidePrevTransitionEnd?: () => any;

        /**
         * Triggered in the beginning of transition.
         */
        transitionStart?: () => any;

        /**
         * Triggered after transition.
         */
        transitionEnd?: () => any;

        /**
         * Triggered when user touch Swiper. Receives 'touchstart' event as an arguments.
         */
        touchStart?: (event: any) => any;

        /**
         * Triggered when user touch and move finger over Swiper. Receives 'touchmove' event as an arguments.
         */
        touchMove?: (event: any) => any;

        /**
         * Fired when user touch and move finger over
         * Swiper in direction opposite to direction parameter.
         * Receives 'touchmove' event as an arguments.
         */
        touchMoveOpposite?: (event: any) => any;

        /**
         * Triggered when user touch and move finger over Swiper and move it.
         * Receives 'touchmove' event as an arguments.
         */
        sliderMove?: (event: any) => any;

        /**
         * Triggered when user release Swiper. Receives 'touchend' event as an arguments.
         */
        touchEnd?: (event: any) => any;

        /**
         * Triggered when user click/tap on Swiper after 300ms delay. Receives 'touchend' event as an arguments.
         */
        click?: (event: any) => any;

        /**
         * Triggered when user click/tap on Swiper. Receives 'touchend' event as an arguments.
         */
        tap?: (event: any) => any;

        /**
         * Triggered when user double tap on Swiper's container. Receives 'touchend' event as an arguments
         */
        doubleTap?: (event: any) => any;

        /**
         * Triggered right after all inner images are loaded. updateOnImagesReady should be also enabled
         */
        imagesReady?: () => any;

        /**
         * Triggered when Swiper progress is changed, as an arguments it receives
         * progress that is always from 0 to 1
         */
        progress?: (progress: any) => any;

        /**
         * Triggered when Swiper reach its beginning (initial position)
         */
        reachBeginning?: () => any;

        /**
         * Triggered when Swiper reach last slide
         */
        reachEnd?: () => any;

        /**
         * Triggered when Swiper goes from beginning or end position
         */
        fromEdge?: () => any;

        /**
         * Triggered when swiper's wrapper change its position. Receives current translate value as an arguments
         */
        setTranslate?: (translate: any) => any;

        /**
         * Triggered everytime when swiper starts animation.
         * Receives current transition duration (in ms) as an arguments,
         */
        setTransition?: (transition: any) => any;

        /**
         * Triggered on window resize right before swiper's onresize manipulation
         */
        resize?: () => any;
    }

    interface NavigationOptions {
        /**
         * String with CSS selector or HTML element of the element that will work
         * like "next" button after click on it
         *
         * @default null
         */
        nextEl?: SelectableElement;

        /**
         * String with CSS selector or HTML element of the element that will work
         * like "prev" button after click on it
         *
         * @default null
         */
        prevEl?: SelectableElement;

        /**
         * buttons visibility after click on Slider's container
         *
         * @default false Toggle navigation
         */
        hideOnClick?: boolean;

        /**
         * CSS class name added to navigation button when it becomes disabled
         *
         * @default 'swiper-button-disabled'
         */
        disabledClass?: string;

        /**
         * CSS class name added to navigation button when it becomes hidden
         *
         * @default 'swiper-button-hidden'
         */
        hiddenClass?: string;
    }

    interface PaginationOptions {
        el: SelectableElement;

        type?: 'bullets' | 'fraction' | 'progressbar' | 'custom';

        bulletElement?: string;

        dynamicBullets?: boolean;

        hideOnClick?: boolean;

        clickable?: boolean;

        /**
         * format fraction pagination current number. Function receives current number,
         * and you need to return formatted value
         */
        formatFractionCurrent?: (number: number) => number;

        /**
         * format fraction pagination total number. Function receives total number, and you
         * need to return formatted value
         */
        formatFractionTotal?: (number: number) => number;

        renderBullet?: (index: number, className: string) => void;

        renderFraction?: (currentClass: string, totalClass: string) => void;

        renderProgressbar?: (progressbarFillClass: string) => void;

        /**
         * This parameter is required for custom pagination type where you have to specify
         * how it should be rendered.
         *
         * @example
         * var swiper = new Swiper('.swiper-container', {
         *   //...
         *   renderCustom: function (swiper, current, total) {
         *     return current + ' of ' + total;
         *   }
         * });
         */
        renderCustom?: (swiper: Swiper, current: number, total: number) => void;

        bulletClass?: string;
        bulletActiveClass?: string;
        modifierClass?: string;
        currentClass?: string;
        totalClass?: string;
        hiddenClass?: string;
        progressbarFillClass?: string;
        clickableClass?: string;
    }

    /**
     * Object with scrollbar parameters.
     *
     * @example
     * var mySwiper = new Swiper('.swiper-container', {
     *   scrollbar: {
     *     el: '.swiper-scrollbar',
     *     draggable: true,
     *   },
     * });
     */
    interface ScrollbarOptions {
        /**
         * String with CSS selector or HTML element of the container with scrollbar.
         */
        el: SelectableElement;

        /**
         * Hide scrollbar automatically after user interaction
         *
         * @default true
         */
        hide?: boolean;

        /**
         * Set to true to enable make scrollbar draggable that allows you to control slider position
         *
         * @default true
         */
        draggable?: boolean;

        /**
         * Set to true to snap slider position to slides when you release scrollbar
         *
         * @default false
         */
        snapOnRelease?: boolean;

        /**
         * Size of scrollbar draggable element in px
         *
         * @default 'auto'
         */
        dragSize?: 'auto' | number;

        /**
         * Scrollbar element additional CSS class when it is disabled
         *
         * @default 'swiper-scrollbar-lock'
         */
        lockClass?: string;

        /**
         * 	Scrollbar draggable element CSS class
         *
         * @default 'swiper-scrollbar-drag'
         */
        dragClass?: string;
    }

    /**
     * Object with autoplay parameters or boolean true to enable with default settings.
     *
     * @example
     * var mySwiper = new Swiper('.swiper-container', {
     *   autoplay: {
     *     delay: 5000,
     *   },
     * });
     */
    interface AutoplayOptions {
        /**
         * Delay between transitions (in ms). If this parameter is not specified, auto play will be disabled
         *
         * If you need to specify different delay for specifi slides you can do it by using
         * data-swiper-autoplay (in ms) attribute on slide.
         *
         * @example
         * <!-- hold this slide for 2 seconds -->
         * <div class="swiper-slide" data-swiper-autoplay="2000">
         *
         * @default 3000
         */
        delay?: number;

        /**
         * Enable this parameter and autoplay will be stopped when it reaches last slide (has no effect in loop mode)
         *
         * @default false
         */
        stopOnLastSlide?: boolean;

        /**
         * Set to false and autoplay will not be disabled after
         * user interactions (swipes), it will be restarted
         * every time after interaction
         *
         * @default true
         */
        disableOnInteraction?: boolean;

        /**
         * Enables autoplay in reverse direction
         *
         * @default false
         */
        reverseDirection?: boolean;

        /**
         * When enabled autoplay will wait for wrapper transition to continue.
         * Can be disabled in case of using Virtual Translate when your
         * slider may not have transition
         *
         * @default true
         */
        waitForTransition?: boolean;
    }

    interface LazyOptions {
        loadPrevNext?: boolean;
        loadPrevNextAmount?: number;
        loadOnTransitionStart?: boolean;
        elementClass?: string;
        loadingClass?: string;
        loadedClass?: string;
        preloaderClass?: string;
    }

    /*
     * Options - Effect
     */

    interface FadeEffectOptions {
        crossfade?: boolean;
    }

    interface CoverflowEffectOptions {
        slideShadows?: boolean;
        rotate?: number;
        stretch?: number;
        depth?: number;
        modifier?: number;
    }

    interface FlipEffectOptions {
        slideShadows?: boolean;
        limitRotation?: boolean;
    }

    interface CubeEffectOptions {
        slideShadows?: boolean;
        shadow?: boolean;
        shadowOffset?: number;
        shadowScale?: number;
    }

    interface ZoomOptions {
        maxRatio?: number;
        minRatio?: number;
        toggle?: boolean;
        containerClass?: string;
        zoomedSlideClass?: string;
    }

    interface KeyboardOptions {
        enabled?: boolean;
        onlyInViewport?: boolean;
    }

    interface MousewheelOptions {
        forceToAxis?: boolean;
        releaseOnEdges?: boolean;
        invert?: boolean;
        sensitivity?: number;
        eventsTarged?: SelectableElement;
    }

    interface VirtualOptions {
        slides?: any[];
        cache?: boolean;
        renderSlide?: (slide: any, index: any) => any;
        renderExternal?: (data: any) => any;
    }

    interface HashNavigationOptions {
        /**
         * Set to true to enable also navigation through slides (when hashnav
         * is enabled) by browser history or by setting directly hash on document location
         *
         * @default false
         */
        watchState?: boolean;

        /**
         * Works in addition to hashnav to replace current url state with the
         * new one instead of adding it to history
         *
         * @default 	false
         */
        replaceState?: boolean;
    }

    interface HistoryNavigationOptions {
        /**
         * Works in addition to hashnav or history to replace current url state with the
         * new one instead of adding it to history
         *
         * @default false
         */
        replaceState?: boolean;

        /**
         * Url key for slides
         *
         * @default 'slides'
         */
        key?: string;
    }

    /**
     * Object with controller parameters or boolean true to enable with default settings. For example:
     *
     * @example
     * var mySwiper = new Swiper('.swiper-container', {
     *   controller: {
     *     inverse: true,
     *   },
     * });
     */
    interface ControllerOptions {
        /**
         * Pass here another Swiper instance or array with Swiper instances that should be controlled
         * by this Swiper
         */
        control?: Swiper;

        /**
         * Set to true and controlling will be in inverse direction
         *
         * @default false
         */
        inverse?: boolean;

        /**
         * Can be 'slide' or 'container'. Defines a way how to control another slider: slide by slide
         * (with respect to other slider's grid) or depending on all slides/container
         * (depending on total slider percentage).
         *
         * @default 'slide'
         */
        by?: 'slide' | 'container';
    }

    interface A11yOptions {
        /**
         * Enables A11y
         *
         * @default true
         */
        enabled?: boolean;

        /**
         * Message for screen readers for previous button
         *
         * @default 'Previous slide'
         */
        prevSlideMessage?: string;

        /**
         * Message for screen readers for next button
         *
         * @default 'Next slide'
         */
        nextSlideMessage?: string;

        /**
         * Message for screen readers for previous button when swiper is on first slide
         *
         * @default 'This is the first slide'
         */
        firstSlideMessage?: string;

        /**
         * Message for screen readers for previous button when swiper is on last slide
         *
         * @default 'This is the last slide'
         */
        lastSlideMessage?: string;

        /**
         * Message for screen readers for single pagination bullet
         *
         * @default 'Go to slide {{index}}'
         */
        paginationBulletMessage?: string;

        /**
         * CSS class name of a11 notification
         *
         * @default 'swiper-notification'
         */
        notificationClass?: string;
    }

    /*
     * Swiper exports the following as ES5 module (in swiper.esm.js).
     */

    /**
     * Virtual Slides module.
     */
    class Virtual {
        /**
         * Object with cached slides HTML elements
         */
        cache: object;

        /**
         * Index of first rendered slide
         */
        from: number;

        /**
         * Index of last rendered slide
         */
        to: number;

        /**
         * Array with slide items passed by virtual.slides parameter
         */
        slides: any[];

        /*
         * Methods
         */

        /**
         * Add new slides to the end. slides could be HTMLElement or HTML string with new slide or array
         * with such slides, for example:
         *
         * @example
         * mySwiper.appendSlide('<div class="swiper-slide">Slide 10"</div>')
         * mySwiper.appendSlide([
         *   '<div class="swiper-slide">Slide 10"</div>',
         *   '<div class="swiper-slide">Slide 11"</div>'
         * ]);
         */
        appendSlide(slide: HTMLElement | string): void;

        /**
         * Add new slides to the beginning. slides could be HTMLElement or HTML string with new slide or
         * array with such slides, for example:
         *
         * @example
         * mySwiper.prependSlide('<div class="swiper-slide">Slide 0"</div>')
         * mySwiper.prependSlide([
         * '<div class="swiper-slide">Slide 1"</div>',
         * '<div class="swiper-slide">Slide 2"</div>'
         * ]);
         */
        prependSlide(slide: HTMLElement | string): void;

        /**
         * Update virutal slides state
         */
        update(): void;
    }

    /**
     * Keyboard Control module.
     */
    class Keyboard {
        /**
         * Whether the keyboard control is enabled
         */
        enabled: boolean;

        // Methods
        /**
         * Enable keyboard control
         */
        enable(): void;

        /**
         * Disable keyboard control
         */
        disable(): void;
    }

    /**
     * Mousewheel Control module.
     */
    class Mousewheel {
        /**
         * Whether the mousewheel control is enabled
         */
        enabled: boolean;

        // Methods
        /**
         * Enable mousewheel control
         */
        enable(): void;

        /**
         * Disable mousewheel control
         */
        disable(): void;
    }

    /**
     * Navigation module.
     */
    class Navigation {
        /**
         * HTMLElement of "next" navigation button
         */
        nextEl: HTMLElement;

        /**
         * HTMLElement of "previous" navigation button
         */
        prevEl: HTMLElement;

        /**
         * Update navigation buttons state (enabled/disabled)
         */
        update(): void;
    }

    /**
     * Pagination module.
     */
    class Pagination {
        /**
         * HTMLElement of pagination container element
         */
        el: HTMLElement;

        /**
         * Dom7 array-like collection of pagination bullets
         * HTML elements. To get specific slide HTMLElement
         * use `mySwiper.pagination.bullets[1]`.
         */
        bullets: DOM7Element[];

        /**
         * Render pagination layout
         */
        render(): void;

        /**
         * Update pagination state (enabled/disabled/active)
         */
        update(): void;
    }

    /**
     * Scrollbar module.
     */
    class Scrollbar {
        // Properties
        /**
         * HTMLElement of Scrollbar container element
         */
        el: HTMLElement;

        /**
         * HTMLElement of Scrollbar draggable handler element
         */
        dragEl: HTMLElement;

        // Methods
        /**
         * Updates scrollbar track and handler sizes
         */
        updateSize(): void;
    }

    /**
     * Parallax module.
     */
    class Parallax { }

    /**
     * Zoom module.
     */
    class Zoom {
        /**
         * Whether the zoom module is enabled
         */
        enabled: boolean;

        /**
         * Current image scale ratio
         */
        scale: number;

        /**
         * Enable zoom module
         */
        enable(): void;

        /**
         * Disable zoom module
         */
        disable(): void;

        /**
         * Zoom in image of the currently active slide
         */
        in(): void;

        /**
         * Zoom out image of the currently active slide
         */
        out(): void;

        /**
         * Toggle image zoom of the currently active slide
         */
        toggle(): void;
    }

    /**
     * Lazy module.
     */
    class Lazy {
        /**
         * Load/update lazy images based on current slider state (position)
         */
        load(): void;

        /**
         * Force to load lazy images in slide by specified index
         * @param number index number of slide to load lazy images in
         */
        loadInSlide(index: number): void;
    }

    /**
     * Controller module.
     */
    class Controller {
        /**
         * Pass here another Swiper instance or array with Swiper instances that should be controlled
         * by this Swiper
         */
        control?: Swiper;
    }

    /**
     * Accessibility module (a11y$)
     */
    class A11y { }

    /**
     * History Navigation module.
     */
    class History { }

    /**
     * Hash Navigation module.
     */
    class HashNavigation {
    }

    /**
     * Autoplay module.
     */
    class Autoplay {
        // Properties
        /**
         * Whether autoplay enabled and running
         */
        running: boolean;

        // Methods
        /**
         * Start autoplay
         */
        start(): boolean;

        /**
         * Stop autoplay
         */
        stop(): boolean;
    }

    /**
     * Fade Effect module.
     */
    class FadeEffect { }

    /**
     * Cube Effect module.
     */
    class CubeEffect { }

    /**
     * Flip Effect module.
     */
    class FlipEffect { }

    /**
     * Coverflow Effect module.
     */
    class CoverflowEffect { }

    /**
     * Core module
     */
    class Swiper {
        /**
         * Constructs a new Swiper instance.
         *
         * @param container Where Swiper applies to.
         * @param options   Instance options.
         */
        constructor(container: SelectableElement, options?: SwiperOptions);

        /**
         * Object with passed initialization parameters
         */
        params: SwiperOptions;

        /**
         * Element with slider container.
         */
        el: HTMLElement;

        /**
         * Dom7 element with slider container HTML element. To get vanilla HTMLElement use el
         */
        $el: DOM7Element;

        /**
         * Slider wrapper HTML element.
         */
        wrapperEl: HTMLElement;

        /**
         * Dom7 element with slider wrapper HTML element. To get vanilla HTMLElement use wrapperEl
         */
        $wrapperEl: DOM7Element;

        /**
         * Dom7 array-like collection of slides HTML elements. To get specific slide HTMLElement use slides[1]
         */
        slides: DOM7Element[];

        /**
         * Width of container
         */
        width: number;

        /**
         * Height of container
         */
        height: number;

        /**
         * Current value of wrapper translate
         */
        translate: number;

        /**
         * Current progress of wrapper translate (from 0 to 1)
         */
        progress: number;

        /**
         * Index number of currently active slide.
         *
         * @note Note, that in loop mode active index value will be always shifted
         * on a number of looped/duplicated slides.
         */
        activeIndex: number;

        /**
         * Index number of currently active slide considering duplicated slides in loop mode
         */
        realIndex: number;

        /**
         * Index number of previously active slide
         */
        previousIndex: number;

        /**
         * true if slider on most "left"/"top" position
         */
        isBeginning: true;

        /**
         * true if slider on most "right"/"bottom" position
         */
        isEnd: boolean;

        /**
         * true if swiper is in transition
         */
        animating: boolean;

        /**
         * Object with the following touch event properties:
         */
        touches: {
            startX: number;
            startY: number;
            currentX: number;
            currentY: number;
            diff: number;
        };

        /**
         * Index number of last clicked slide
         */
        clickedIdex: number;

        /**
         * Link to last clicked slide (HTMLElement)
         */
        clickedSlide: HTMLElement;

        /**
         * Disable/enable ability to slide to the next slides by assigning false/true to this property
         *
         * @default true
         */
        allowSlideNext: boolean;

        /**
         * Disable/enable ability to slide to the previous slides by assigning false/true to this property
         *
         * @default true
         */
        allowSlidePrev: boolean;

        /**
         * Disable/enable ability move slider by grabbing it with
         * mouse or by touching it with finger (on touch screens)
         * by assigning false/true to this property
         *
         * @default true
         */
        allowTouchMove: boolean;

        // Methods
        /**
         * Run transition to next slide.
         *
         * @param speed Transition duration (in ms).
         * @param runCallbacks Set it to false (by default it is true) and transition will
         *  not produce transition events.
         */
        slideNext(speed: number, runCallbacks: boolean): void;

        /**
         * Run transition to previous slide.
         *
         * @param speed Transition duration (in ms).
         * @param runCallbacks Set it to false (by default it is true) and transition will
         *  not produce transition events.
         */
        slidePrev(speed?: number, runCallbacks?: boolean): void;

        /**
         * Run transition to the slide with index number equal to 'index' parameter for the
         *  duration equal to 'speed' parameter.
         *
         * @param index Index number of slide.
         * @param speed Transition duration (in ms).
         * @param runCallbacks Set it to false (by default it is true) and transition will
         *  not produce transition events.
         */
        slideTo(index: number, speed?: number, runCallbacks?: boolean): void;

        /**
         * You should call it after you add/remove slides
         * manually, or after you hide/show it, or do any
         * custom DOM modifications with Swiper
         * This method also includes subcall of the following
         * methods which you can use separately:
         */
        update(): void;

        /**
         * recalculate size of swiper container
         */
        updateSize(): void;

        /**
         * recalculate number of slides and their offsets. Useful after you add/remove slides with JavaScript
         */
        updateSlides(): void;

        /**
         * recalculate swiper progress
         */
        updateProgress(): void;

        /**
         * update active/prev/next classes on slides and bullets
         */
        updateSlidesClasses(): void;

        /**
         * tach all events listeners
         */
        detachEvents(): void;

        /**
         * Atach all events listeners again
         */
        attachEvents(): void;

        /**
         * Destroy slider instance and detach all events listeners, where
         */
        destroy(deleteInstance: boolean, cleanupStyles: boolean): void;

        /**
         * Set it to false (by default it is true) to not to delete Swiper instance
         */
        deleteInstance: boolean;

        /**
         * Set it to true (by default it is true) and all
         * custom styles will be removed from slides,
         * wrapper and container. Useful if you need to
         * destroy Swiper and to init again with new
         * options or in different direction
         */
        cleanStyles: boolean;

        /**
         * Installs modules on Swiper in runtime.
         */
        static use(modules: SwiperModule[]): void;

        /**
         * Add new slides to the end. slides could be
         * HTMLElement or HTML string with new slide or
         * array with such slides, for example:
         *
         * @example appendSlide('<div class="swiper-slide">Slide 10"</div>')
         * @example
         * appendSlide([
         *  '<div class="swiper-slide">Slide 10"</div>',
         *  '<div class="swiper-slide">Slide 11"</div>'
         * ]);
         */
        appendSlide(slides: HTMLElement | string | string[]): void;

        /**
         * Add new slides to the beginning. slides could be
         * HTMLElement or HTML string with new slide or array with such slides, for example:
         *
         * @example prependSlide('<div class="swiper-slide">Slide 0"</div>')
         * @example prependSlide([
         *  '<div class="swiper-slide">Slide 1"</div>',
         *  '<div class="swiper-slide">Slide 2"</div>'
         * ]);
         */
        prependSlide(slides: HTMLElement | string | string[]): void;

        /**
         * Remove selected slides. slideIndex could be a number with slide index to remove or array with indexes.
         *
         * @example removeSlide(0); // remove first slide
         * @example removeSlide([0, 1]); // remove first and second slides
         * @example removeAllSlides();	// Remove all slides
         */
        removeSlide(slideIndex: number | number[]): void;

        /**
         * Set custom css3 transform's translate value for swiper wrapper
         */
        setTranslate(translate: any): void;

        /**
         * Get current value of swiper wrapper css3 transform translate
         */
        getTranslate(): any;

        /**
         * Add event listener
         */
        on(event: SwiperEvent, handler: () => void): void;

        /**
         * Add event listener that will be executed only once
         */
        once(event: SwiperEvent, handler: () => void): void;

        /**
         * Remove event listener for specified event
         * If no handler specified, removes all listeners for specified event
         */
        off(event: SwiperEvent, handler?: () => void): void;

        /**
         * Disable mousewheel control
         */
        disableMousewheelControl(): void;

        /**
         * Enable mousewheel control
         */
        enableMousewheelControl(): void;

        /**
         * Disable keyboard control
         */
        disableKeyboardControl(): void;

        /**
         * Enable keyboard control
         */
        enableKeyboardControl(): void;

        /**
         * Unset grab cursor
         */
        unsetGrabCursor(): void;

        /**
         * Set grab cursor
         */
        setGrabCursor(): void;

        // Components

        /**
         * Swiper Navigation module.
         */
        navigation?: Navigation;

        /**
         * Swiper Pagination module.
         */
        pagination?: Pagination;

        /**
         * Swiper Scrollbar module.
         */
        scrollbar?: Scrollbar;

        /**
         * Swiper Autoplay module.
         */
        autoplay?: Autoplay;

        /**
         * Swiper Parallax module.
         */
        parallax?: Parallax;

        /**
         * Swiper Lazy module.
         */
        lazy?: Lazy;

        /**
         * Swiper FadeEffect module.
         */
        fadeEffect?: FadeEffect;

        /**
         * Swiper CoverflowEffect module.
         */
        coverflowEffect?: CoverflowEffect;

        /**
         * Swiper FlipEffect module.
         */
        flipEffect?: FlipEffect;

        /**
         * Swiper CubeEffect module.
         */
        cubeEffect?: CubeEffect;

        /**
         * Swiper Zoom module.
         */
        zoom?: Zoom;

        /**
         * Swiper Keyboard module.
         */
        keyboard?: Keyboard;

        /**
         * Swiper Mousewheel module.
         */
        mousewheel?: Mousewheel;

        /**
         * Swiper Virtual module.
         */
        virtual?: Virtual;

        /**
         * Swiper HashNavigation module.
         */
        hashNavigation?: HashNavigation;

        /**
         * Swiper History module.
         */
        history?: History;

        /**
         * Swiper Controller module.
         */
        controller?: Controller;

        /**
         * Swiper A11y module.
         */
        a11y?: A11y;
    }
}

// Use thru this when in TypeScript
declare module 'swiper/dist/js/swiper.esm' {
    import alias = require('swiper');
    export = alias;
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--
Pass: (3300) Inconsistent math
-->
<sbml xmlns="http://www.sbml.org/sbml/level2" level="2" version="1">
  <model>
    <listOfCompartments>
      <compartment id="c" constant="true" spatialDimensions="3"/>
    </listOfCompartments>
    <listOfParameters>
      <parameter id="p" value="1" units="metre" constant="false"/>
    </listOfParameters>
    <listOfRules>
      <algebraicRule>
        <math xmlns="http://www.w3.org/1998/Math/MathML">
          <apply>
            <power/>
            <ci> p </ci>
            <cn type="rational"> 2 <sep/> 3 </cn>
          </apply>
        </math>
      </algebraicRule>
    </listOfRules>
  </model>
</sbml>


text:
set -e
set -x

platform="$(uname)"
if [ "$platform" = "Darwin" ]; then
	unzip comet_source_"$PKG_VERSION".zip
	sed -i '' -e 's/ -static//' -e 's/ -o / -headerpad_max_install_names&/' Makefile
	sed -i '' -e "s/sha1Report='..'/sha1Report=NULL/" MSToolkit/include/MSReader.h
	make
elif [ "$platform" = "Linux" ]; then
	mv comet."$PKG_VERSION".linux.exe comet.exe
fi
chmod 755 comet.exe
mkdir -p "$PREFIX"/bin
cp comet.exe "$PREFIX"/bin/comet
cd "$PREFIX"/bin/
ln -s comet comet.exe


text:
package mount

import (
	"bufio"
	"bytes"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"strings"

	"github.com/docker/docker/pkg/mount"
)

const (
	/* 36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
	   (1)(2)(3)   (4)   (5)      (6)      (7)   (8) (9)   (10)         (11)

	   (1) mount ID:  unique identifier of the mount (may be reused after umount)
	   (2) parent ID:  ID of parent (or of self for the top of the mount tree)
	   (3) major:minor:  value of st_dev for files on filesystem
	   (4) root:  root of the mount within the filesystem
	   (5) mount point:  mount point relative to the process's root
	   (6) mount options:  per mount options
	   (7) optional fields:  zero or more fields of the form "tag[:value]"
	   (8) separator:  marks the end of the optional fields
	   (9) filesystem type:  name of filesystem of the form "type[.subtype]"
	   (10) mount source:  filesystem specific information or "none"
	   (11) super options:  per super block options*/
	mountinfoFormat = "%d %d %d:%d %s %s %s %s"
)

// ErrLimitReached means that the read limit is reached.
var ErrLimitReached = errors.New("the read limit is reached")

// Parse /proc/self/mountinfo because comparing Dev and ino does not work from
// bind mounts. function is originally from
// https://github.com/moby/sys/blob/65f80e71a828ef17e6f573176dc569e55f519937/mountinfo/mountinfo_linux.go
func parseMountTable() ([]*mount.Info, error) {
	mountInfoBytes, err := consistentRead("/proc/self/mountinfo", 3)
	if err != nil {
		return nil, err
	}

	return parseInfoFile(bytes.NewReader(mountInfoBytes))
}

// consistentRead repeatedly reads a file until it gets the same content twice.
// This is useful when reading files in /proc that are larger than page size
// and kernel may modify them between individual read() syscalls.
// originally from https://github.com/kubernetes/utils/blob/a0dff01d8ea5b4e8799d52a7fad727caafc9c685/io/read.go#L33-L35
func consistentRead(filename string, attempts int) ([]byte, error) {
	oldContent, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}
	for i := 0; i < attempts; i++ {
		newContent, err := ioutil.ReadFile(filename)
		if err != nil {
			return nil, err
		}
		if bytes.Compare(oldContent, newContent) == 0 {
			return newContent, nil
		}
		// Files are different, continue reading
		oldContent = newContent
	}
	return nil, fmt.Errorf("could not get consistent content of mount table after %d attempts", attempts)
}

func parseInfoFile(r io.Reader) ([]*mount.Info, error) {
	var (
		s   = bufio.NewScanner(r)
		out = []*mount.Info{}
	)

	for s.Scan() {
		if err := s.Err(); err != nil {
			return nil, err
		}

		var (
			p              = &mount.Info{}
			text           = s.Text()
			optionalFields string
		)

		if _, err := fmt.Sscanf(text, mountinfoFormat,
			&p.ID, &p.Parent, &p.Major, &p.Minor,
			&p.Root, &p.Mountpoint, &p.Opts, &optionalFields); err != nil {
			return nil, fmt.Errorf("Scanning '%s' failed: %s", text, err)
		}
		// Safe as mountinfo encodes mountpoints with spaces as \040.
		index := strings.Index(text, " - ")
		postSeparatorFields := strings.Fields(text[index+3:])
		if len(postSeparatorFields) < 3 {
			return nil, fmt.Errorf("Error found less than 3 fields post '-' in %q", text)
		}

		if optionalFields != "-" {
			p.Optional = optionalFields
		}

		p.Fstype = postSeparatorFields[0]
		p.Source = postSeparatorFields[1]
		p.VfsOpts = strings.Join(postSeparatorFields[2:], " ")
		out = append(out, p)
	}
	return out, nil
}


text:
ePO Certificate Verification
============================

The ePO DXL service supports validating the authenticity of the certificate associated with each ePO server that is
being connected to.

Enabling and disabling of this capability is controlled via the ``verifyCertificate`` property that is associated with
each ePO server defined within the server configuration file
(see :ref:`Service Configuration File <dxl_service_config_file_label>`). While this validation can be disabled, it
is highly recommended that it be enabled for production environments.

The remainder of this page walks through the steps necessary to obtain the information required to perform this
validation successfully.

Two types of certificate validation take place when connecting to an ePO server:

1. The ``host`` as defined in the service configuration file for the ePO server must match the hostname in the
   ePO server's certificate.
2. The ePO server's certificate must be signed by a Certificate Authority (CA) that can be found in the
   CA bundle (specified via the ``verifyCertBundle`` property) associated with the ePO server in the service
   configuration file.

To determine the hostname in the ePO server's certificate and the certificate of the signing CA you can execute
the following command via ``openssl``.

    .. parsed-literal::

        openssl s_client -showcerts -connect <epo-host>:<epo-port>

For example:

    .. parsed-literal::

        openssl s_client -showcerts -connect epotestsystem:8443

The output of the command should appear similar to the following:

    .. parsed-literal::

        CONNECTED(00000003)
        depth=1 O = McAfee, OU = Orion, CN = Orion_CA_epotestsystem
        verify error:num=19:self signed certificate in certificate chain
        ---
        Certificate chain
         0 s:/O=McAfee/OU=Orion/\ **CN=epotestsystem**
           i:/O=McAfee/OU=Orion/CN=Orion_CA_epotestsystem
        -----BEGIN CERTIFICATE-----
        MIIDQTCCAimgAwIBAgIIbIZ7jokCYykwDQYJKoZIhvcNAQEFBQAwPDEPMA0GA1UE
        CgwGTWNBZmVlMQ4wDAYDVQQLDAVPcmlvbjEZMBcGA1UEAwwQT3Jpb25fQ0FfRFhM
        LUVQTzAeFw03MDAxMDEwMDAwMDBaFw00NjA5MDUyMzM3MjVaMDMxDzANBgNVBAoM
        Bk1jQWZlZTEOMAwGA1UECwwFT3Jpb24xEDAOBgNVBAMMB0RYTC1FUE8wggEiMA0G
        CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCPBctQ4yvubzJlJII4yiFaLbch0dFy
        aUHR6WUJUumAMgHr5Qk06t/I5zFbAvEQYzKsWpX5qPLt90ZwVdEYipTDeuR4zp5c
        AUy8tgPNGGVwdcLraw6du/qw4knOsI9aWzQ0iCXKkthOEAtV+6CPeKVtKfjNi0la
        UsX0s7S3PQzEjppDVojoXAyt0EA0d38mEEoNpt02oJpCldo8JAtLB8GytVkYxxNi
        aSMfb/Ix36PQXZuU7id1xA7y0oT9slBY3Scs4H0vr1FAv4a9ChE7sCOFH9ng+MbM
        kPjBVevcSIsOcZdfs4ACGwiPrp0rWxGl71frJ0qx4RQnWbBq4jRPRNQ7AgMBAAGj
        UDBOMAwGA1UdEwEB/wQCMAAwHQYDVR0OBBYEFOnjEeu4L3W6Qyc/r37OJaMi5mfh
        MB8GA1UdIwQYMBaAFKitli7CNwfamTztGieYRrWLs57FMA0GCSqGSIb3DQEBBQUA
        A4IBAQARcMWJnIKC97cqT8ok0w3sEaVhplkI518tnctyoHgcavNRbbNFMjWWybzp
        +zrGCehV7j+IIeVI8Zkxom6CByeAl//J4IeZe8T862ZRvjy9oNeojlmWXlAhSX+2
        8NzATXCvmVzM+qE3F+k1cpD8MFwkIdPY6osOqdPM7Fit04jwizdyg5JFkJPH7aeB
        FzngfaQOcZv+WFfcMNftUIpRlusRsvYdU8TU3mYCi5G5L3Uva4RLsmb3z5m/V+f4
        CGrL15OX6nduGr5D8mfWHXdlxF1KWx7FlCHdgzHws5+w+KIPoDr0u5XK38xxBXIm
        KTyOYAwDg5Mo/2R33q/Fy1fsY8nG
        -----END CERTIFICATE-----
         1 s:/O=McAfee/OU=Orion/CN=Orion_CA_epotestsystem
           i:/O=McAfee/OU=Orion/CN=Orion_CA_epotestsystem
        **-----BEGIN CERTIFICATE-----
        MIIDTTCCAjWgAwIBAgIIffd6gTDU39wwDQYJKoZIhvcNAQEFBQAwPDEPMA0GA1UE
        CgwGTWNBZmVlMQ4wDAYDVQQLDAVPcmlvbjEZMBcGA1UEAwwQT3Jpb25fQ0FfRFhM
        LUVQTzAeFw03MDAxMDEwMDAwMDBaFw00NjA5MDUyMzM3MjRaMDwxDzANBgNVBAoM
        Bk1jQWZlZTEOMAwGA1UECwwFT3Jpb24xGTAXBgNVBAMMEE9yaW9uX0NBX0RYTC1F
        UE8wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDRMqxPEBBkYrcmWg5T
        X2r3Z+bidvGGcPzA2vACvdY4DCGkLTtc085EOQoULRNdGSI6yP9W9YH8nquTreHW
        O80Aj29kr9Il3+JXad04LzBbjW5MhMCf4fnGiJ5E9ud2BE/xc6RTco/8bIoR27BC
        VoTnyHcU0gHz7+PZWaQrPhRKEaNbG3RddY7zKjq56s32rBti2LBbjGg7qVSMLewy
        MuBl9owzWwYC8bJnbqHH3h4LdtsG/Zb1ohsR2PaY2gb+Bn2DjWlBVFiFozRKKSLU
        ipXlBxiYRRrkfOhEneWiptdLo65cXLd09hRc8h7dEPlYl9jZHGpOBvX1aGjre8w8
        LlrXAgMBAAGjUzBRMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFKitli7CNwfa
        mTztGieYRrWLs57FMB8GA1UdIwQYMBaAFKitli7CNwfamTztGieYRrWLs57FMA0G
        CSqGSIb3DQEBBQUAA4IBAQAyHKcG55dOvJJPRf9Xt+Uj3nwd1gyehbOhKJYfDqeZ
        l5EYGuNpX3HFl3BLjNxqxoj/aw1ICJX4AQQpFRsnB2CjQA53/1+0Cmvq4lw7qL/A
        5sbshJKy+4291THE16ynqAF2cySlxhdSpvDMB3Z0v9iGqt5yYvhMc5yHhCpipj0r
        iYY/K8QhEtruGy4lHxjwKOf5Ky1nX1pAZmRK4IDQTdn4iT3Cl9Jgr+ERFou7PHXN
        0k8wmi1b2oPp5OCJoeB4xzsrbdG2aCgTDTflzL9RiEeflhwlWim2X2oCyZKVW4a4
        /Tzcdk4tZlgZazxEDTJ8wI+12JNGBXMN5fuaF5Yuykf1
        -----END CERTIFICATE-----**

        ...

In the output above, the two important portions for validating the ePO server's certificate have been
highlighted in bold.

1. The first portion includes the common name (CN) associated with the ePO server's certificate.

   In this particular example the CN is as follows: ``CN=epotestsystem``

   Based on this, for hostname validation to succeed the ``host`` value for the ePO server as defined in the
   service configuration file must have a value of ``epotestsystem``.

2. The second portion highlighted is the certificate of the CA that was used to sign the ePO server's certificate.

   For certificate validation to succeed, this certificate text must be copied (including the `BEGIN` and `END` lines)
   into a new file. Next, the ``verifyCertBundle`` value for the ePO server as defined in the service configuration
   file must have a path to this newly created file.

   For example:

    .. parsed-literal::

        -----BEGIN CERTIFICATE-----
        MIIDTTCCAjWgAwIBAgIIffd6gTDU39wwDQYJKoZIhvcNAQEFBQAwPDEPMA0GA1UE
        CgwGTWNBZmVlMQ4wDAYDVQQLDAVPcmlvbjEZMBcGA1UEAwwQT3Jpb25fQ0FfRFhM
        LUVQTzAeFw03MDAxMDEwMDAwMDBaFw00NjA5MDUyMzM3MjRaMDwxDzANBgNVBAoM
        Bk1jQWZlZTEOMAwGA1UECwwFT3Jpb24xGTAXBgNVBAMMEE9yaW9uX0NBX0RYTC1F
        UE8wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDRMqxPEBBkYrcmWg5T
        X2r3Z+bidvGGcPzA2vACvdY4DCGkLTtc085EOQoULRNdGSI6yP9W9YH8nquTreHW
        O80Aj29kr9Il3+JXad04LzBbjW5MhMCf4fnGiJ5E9ud2BE/xc6RTco/8bIoR27BC
        VoTnyHcU0gHz7+PZWaQrPhRKEaNbG3RddY7zKjq56s32rBti2LBbjGg7qVSMLewy
        MuBl9owzWwYC8bJnbqHH3h4LdtsG/Zb1ohsR2PaY2gb+Bn2DjWlBVFiFozRKKSLU
        ipXlBxiYRRrkfOhEneWiptdLo65cXLd09hRc8h7dEPlYl9jZHGpOBvX1aGjre8w8
        LlrXAgMBAAGjUzBRMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFKitli7CNwfa
        mTztGieYRrWLs57FMB8GA1UdIwQYMBaAFKitli7CNwfamTztGieYRrWLs57FMA0G
        CSqGSIb3DQEBBQUAA4IBAQAyHKcG55dOvJJPRf9Xt+Uj3nwd1gyehbOhKJYfDqeZ
        l5EYGuNpX3HFl3BLjNxqxoj/aw1ICJX4AQQpFRsnB2CjQA53/1+0Cmvq4lw7qL/A
        5sbshJKy+4291THE16ynqAF2cySlxhdSpvDMB3Z0v9iGqt5yYvhMc5yHhCpipj0r
        iYY/K8QhEtruGy4lHxjwKOf5Ky1nX1pAZmRK4IDQTdn4iT3Cl9Jgr+ERFou7PHXN
        0k8wmi1b2oPp5OCJoeB4xzsrbdG2aCgTDTflzL9RiEeflhwlWim2X2oCyZKVW4a4
        /Tzcdk4tZlgZazxEDTJ8wI+12JNGBXMN5fuaF5Yuykf1
        -----END CERTIFICATE-----


text:
MODULE_INFO(vermagic, VERMAGIC_STRING);

struct module __this_module
__attribute__((section(".gnu.linkonce.this_module"))) = {
 .name = KBUILD_MODNAME,
 .init = init_module,
#ifdef CONFIG_MODULE_UNLOAD
 .exit = cleanup_module,
#endif
 .arch = MODULE_ARCH_INIT,
};

static const char __module_depends[]
__used
__attribute__((section(".modinfo"))) =
"depends=";

MODULE_INFO(srcversion, "D368E62BA68CBAC73362D71");


text:
#if true_NYI

using System;
using System.Collections;
using System.Text;
using System.IO;
using PdfSharp.Internal;

namespace PdfSharp.Pdf.Advanced
{
  /// <summary>
  /// Not implemented - just for illustration of the class hierarchy.
  /// </summary>
  internal sealed class PdfType1Font : PdfFont
  {
    public PdfType1Font(PdfDocument document)
      : base(document)
    {
      this.Elements["\\Type"] = new PdfName("Font");
      this.Elements["\\Subtype"] = new PdfName("Type1");
    }

    //public string BaseFont
    //{
    //  get {return this.baseFont;}
    //  set {this.baseFont = value;}
    //}
    //string baseFont;

//    internal override void AssignObjectID(ref int objectID)
//    {
//      SetObjectID(ref objectID);
//    }
//
//    internal override void WriteObject(Stream stream)
//    {
//      base.WriteObject(stream);
//      StringBuilder pdf = new StringBuilder();
//      pdf.AppendFormat("{0} 0 obj\n<<\n/Type /Font\n/Subtype /Type1\n/BaseFont /Helvetica\n/Encoding /WinAnsiEncoding\n>>\nendobj\n", this.ObjectID);
//      WriteString(stream, pdf.ToString());
//    }
    /// <summary>
    /// Predefined keys of this dictionary.
    /// </summary>
    public new sealed class Keys : PdfFont.Keys
    {
      /// <summary>
      /// (Required) The type of PDF object that this dictionary describes;
      /// must be Font for a font dictionary.
      /// </summary>
      [KeyInfo(KeyType.Name | KeyType.Required, FixedValue = "Font")]
      public new const string Type = "/Type";

      /// <summary>
      /// (Required) The type of font; must be Type1 for a Type 1 font.
      /// </summary>
      [KeyInfo(KeyType.Name | KeyType.Required)]
      public new const string Subtype = "/Subtype";

      /// <summary>
      /// (Required in PDF 1.0; optional otherwise) The name by which this font is
      /// referenced in the Font subdictionary of the current resource dictionary.
      /// </summary>
      [KeyInfo(KeyType.Name | KeyType.Optional)]
      public const string Name = "/Name";

      /// <summary>
      /// (Required) The PostScript name of the font. For Type 1 fonts, this is usually
      /// the value of the FontName entry in the font program; for more information.
      /// The Post-Script name of the font can be used to find the font's definition in
      /// the consumer application or its environment. It is also the name that is used when
      /// printing to a PostScript output device.
      /// </summary>
      [KeyInfo(KeyType.Name | KeyType.Required)]
      public new const string BaseFont = "/BaseFont";

      /// <summary>
      /// (Required except for the standard 14 fonts) The first character code defined
      /// in the font's Widths array.
      /// </summary>
      [KeyInfo(KeyType.Integer)]
      public const string FirstChar = "/FirstChar";

      /// <summary>
      /// (Required except for the standard 14 fonts) The last character code defined
      /// in the font's Widths array.
      /// </summary>
      [KeyInfo(KeyType.Integer)]
      public const string LastChar = "/LastChar";

      /// <summary>
      /// (Required except for the standard 14 fonts; indirect reference preferred)
      /// An array of (LastChar - FirstChar + 1) widths, each element being the glyph width
      /// for the character code that equals FirstChar plus the array index. For character
      /// codes outside the range FirstChar to LastChar, the value of MissingWidth from the
      /// FontDescriptor entry for this font is used. The glyph widths are measured in units
      /// in which 1000 units corresponds to 1 unit in text space. These widths must be
      /// consistent with the actual widths given in the font program.
      /// </summary>
      [KeyInfo(KeyType.Array, typeof(PdfArray))]
      public const string Widths = "/Widths";

      /// <summary>
      /// (Required except for the standard 14 fonts; must be an indirect reference)
      /// A font descriptor describing the font's metrics other than its glyph widths.
      /// Note: For the standard 14 fonts, the entries FirstChar, LastChar, Widths, and
      /// FontDescriptor must either all be present or all be absent. Ordinarily, they are
      /// absent; specifying them enables a standard font to be overridden.
      /// </summary>
      [KeyInfo(KeyType.Dictionary | KeyType.MustBeIndirect, typeof(PdfFontDescriptor))]
      public new const string FontDescriptor = "/FontDescriptor";

      /// <summary>
      /// (Optional) A specification of the font's character encoding if different from its
      /// built-in encoding. The value of Encoding is either the name of a predefined
      /// encoding (MacRomanEncoding, MacExpertEncoding, or WinAnsiEncoding, as described in
      /// Appendix D) or an encoding dictionary that specifies differences from the font's
      /// built-in encoding or from a specified predefined encoding.
      /// </summary>
      [KeyInfo(KeyType.Name | KeyType.Dictionary)]
      public const string Encoding = "/Encoding";

      /// <summary>
      /// (Optional; PDF 1.2) A stream containing a CMap file that maps character
      /// codes to Unicode values.
      /// </summary>
      [KeyInfo(KeyType.Stream | KeyType.Optional)]
      public const string ToUnicode = "/ToUnicode";

      /// <summary>
      /// Gets the KeysMeta for these keys.
      /// </summary>
      internal static DictionaryMeta Meta
      {
        get
        {
          if (Keys.meta == null)
            Keys.meta = CreateMeta(typeof(Keys));
          return Keys.meta;
        }
      }
      static DictionaryMeta meta;
    }

    /// <summary>
    /// Gets the KeysMeta of this dictionary type.
    /// </summary>
    internal override DictionaryMeta Meta
    {
      get {return Keys.Meta;}
    }
  }
}
#endif


text:
if(NOT QT4_FOUND)
  include(FindQt4)
endif(NOT QT4_FOUND)

set(QWT_FOUND NO)

if(QT4_FOUND)
  find_path(QWT_INCLUDE_DIR qwt.h
    PATHS /usr/local/qwt /usr/local /usr/include/qwt-qt4 /usr/include/qwt
          /usr/include/qwt5 /usr /opt/local/include/qwt
    HINTS $ENV{QWT_ROOT} ${QWT_ROOT}
    PATH_SUFFIXES include
  )

  set(QWT_NAMES ${QWT_NAMES} qwt-qt4 qwt5 qwt libqwt-qt4 libqwt)
  find_library(QWT_LIBRARY
    NAMES ${QWT_NAMES}
    PATHS /usr/local/qwt /usr/local /usr $ENV{QWT_ROOT} ${QWT_ROOT}
    PATH_SUFFIXES lib
  )

  if(QWT_LIBRARY)
    set(QWT_LIBRARIES ${QWT_LIBRARY})
    set(QWT_FOUND YES)

  endif(QWT_LIBRARY)
endif(QT4_FOUND)

include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(QWT DEFAULT_MSG QWT_LIBRARIES)

mark_as_advanced(QWT_INCLUDE_DIR QWT_LIBRARY)


text:
package org.apache.karaf.webconsole.examples.events.provider;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

import org.osgi.service.event.Event;
import org.osgi.service.event.EventAdmin;

/**
 * Example brand provider which modify console look and feel.
 */
public class DemoProducer {

    private EventAdmin eventAdmin;
    private List<String> topics;
    private AtomicBoolean run = new AtomicBoolean(true);

    public DemoProducer(EventAdmin eventAdmin) {
        this.eventAdmin = eventAdmin;
    }

    public void setTopics(List<String> topics) {
        this.topics = topics;
    }

    public void start() {
        new Thread(new Runnable() {
            public void run() {
                int counter = 0;
                int topicCount = 0;

                while (run.get()) {
                    if (++topicCount >= topics.size()) {
                        topicCount = 0;
                    }
                    Map properties = new HashMap();
                    properties.put("topicCounter", topicCount);
                    properties.put("counter", ++counter);
                    eventAdmin.postEvent(new Event(topics.get(topicCount), properties));

                    try {
                        Thread.sleep(TimeUnit.SECONDS.toMillis(10));
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    public void stop() {
        run.set(false);
    }

}


text:
require 'yaml'

ACCOUNT = YAML.load_file(File.dirname(__FILE__) + '/account.yml')

def get_api
  Box::Api.new(ACCOUNT['api_key'])
end

def get_account(auth = true)
  Box::Account.new(get_api).tap do |account|
    account.authorize(ACCOUNT['auth_token']) if auth
  end
end

def get_root
  get_account.root
end


text:
/* global UTILS */
'use strict';

angular.module('alienUiApp').factory('defaultNodeRendererService', ['commonNodeRendererService', 'toscaService',
  function(commonNodeRendererService, toscaService) {
    return {

      isRuntime: false,
      width: 200,
      height: 50,
      distanceBetweenBranchHorizontal: 40,
      distanceBetweenNodeHorizontal: 20,
      distanceBetweenNodeVertical: 20,

      setRuntime: function(isRuntime) {
        this.isRuntime = isRuntime;
        if (isRuntime) {
          this.height = 85;
        } else {
          this.height = 50;
        }
      },

      createNode: function(nodeGroup, node, nodeTemplate, nodeType, oX, oY) {
        if (nodeType.tags) {
          var tags = UTILS.convertNameValueListToMap(nodeType.tags);
          if (tags.icon) {
            nodeGroup.append('image').attr('x', oX + 8).attr('y', oY + 8).attr('width', '32').attr('height', '32').attr('xlink:href',
              'img?id=' + tags.icon + '&quality=QUALITY_32');
          }
        }

        if (nodeType.abstract) {
          var icoSize = 16;
          var x = 80;
          var y = -22;
          nodeGroup.append('image').attr('x', x).attr('y', y).attr('width', icoSize).attr('height', icoSize).attr('xlink:href', 'images/abstract_ico.png');
        }

        nodeGroup.append('text').attr('text-anchor', 'start').attr('class', 'title').attr('x', oX + 44).attr('y', oY + 20);
        nodeGroup.append('text').attr('text-anchor', 'end').attr('class', 'version').attr('x', '80').attr('y', '20');

        // specific to the runtime view
        if (this.isRuntime) {
          nodeGroup.append('g').attr('id', 'runtime');
        }
      },

      updateNode: function(nodeGroup, node, nodeTemplate, nodeType, oX, oY, topology) {
        // update text
        nodeGroup.select('.title').text(commonNodeRendererService.getDisplayId(node, false));

        // update version
        nodeGroup.select('.version').text(function() {
          if (UTILS.isDefinedAndNotNull(nodeTemplate.properties) && UTILS.isDefinedAndNotNull(nodeTemplate.properties.version)) {
            return 'v' + nodeTemplate.properties.version.value;
          }
        });

        // runtime infos
        if (this.isRuntime) {
          var runtimeGroup = nodeGroup.select('#runtime');

          var nodeInstances = null;
          var nodeInstancesCount = null;
          var nodeScalingPolicies = null;

          if (UTILS.isDefinedAndNotNull(topology.instances)) {
            nodeInstances = topology.instances[node.id];
            if (UTILS.isDefinedAndNotNull(nodeInstances)) {
              nodeInstancesCount = Object.keys(nodeInstances).length;
              if (topology.topology.hasOwnProperty('scalingPolicies')) {
                nodeScalingPolicies = topology.topology.scalingPolicies[node.id];
              }
            }
          }

          // TODO better draw network node
          if (!toscaService.isOneOfType(['tosca.nodes.Network'], nodeTemplate.type, topology.nodeTypes)) {
            this.drawRuntimeInfos(runtimeGroup, nodeInstances, nodeInstancesCount, oX, oY, nodeScalingPolicies);
          }
        }
      },

      drawRuntimeInfos: function(runtimeGroup, nodeInstances, nodeInstancesCount, rectOriginX, rectOriginY, scalingPolicies) {
        var currentY = rectOriginY + 40;
        var deletedCount = 0;
        if (UTILS.isDefinedAndNotNull(nodeInstances) && nodeInstancesCount > 0) {
          //the deployment status is no more unknown
          this.removeRuntimeCount(runtimeGroup, 'runtime-count-unknown');

          var successCount = this.getNumberOfInstanceByStatus(nodeInstances, 'SUCCESS');
          var processingCount = this.getNumberOfInstanceByStatus(nodeInstances, 'PROCESSING');
          var failureCount = this.getNumberOfInstanceByStatus(nodeInstances, 'FAILURE');
          deletedCount = this.getNumberOfInstanceByStatus(nodeInstances, null, 'stopped');

          // adapt instance count
          if (UTILS.isDefinedAndNotNull(scalingPolicies)) {
            nodeInstancesCount = scalingPolicies.initialInstances;
          }

          if (successCount > 0) {
            this.drawRuntimeCount(runtimeGroup, 'runtime-count-success', rectOriginX, currentY, '\uf00c', successCount, nodeInstancesCount);
            currentY += 20;
          } else {
            this.removeRuntimeCount(runtimeGroup, 'runtime-count-success');
          }
          if (processingCount > 0) {
            this.drawRuntimeCount(runtimeGroup, 'runtime-count-progress', rectOriginX, currentY, '\uf110', processingCount, nodeInstancesCount);
            currentY += 20;
          } else {
            this.removeRuntimeCount(runtimeGroup, 'runtime-count-progress');
          }
          if (failureCount > 0) {
            this.drawRuntimeCount(runtimeGroup, 'runtime-count-failure', rectOriginX, currentY, '\uf00d', failureCount, nodeInstancesCount);
          } else {
            this.removeRuntimeCount(runtimeGroup, 'runtime-count-failure');
          }

          if (nodeInstancesCount === successCount) {
            runtimeGroup.append('circle').attr('cx', rectOriginX + this.width - 17).attr('cy', rectOriginY + 16).attr('r', '12')
              .attr('orient', 'auto').attr('style', 'stroke: none; fill: green');
          } else if (nodeInstancesCount === failureCount) {
            runtimeGroup.append('circle').attr('cx', rectOriginX + this.width - 17).attr('cy', rectOriginY + 16).attr('r', '12')
              .attr('orient', 'auto').attr('style', 'stroke: none; fill: red');
          } else if (nodeInstancesCount === deletedCount) {
            runtimeGroup.append('circle').attr('cx', rectOriginX + this.width - 17).attr('cy', rectOriginY + 16).attr('r', '12').attr(
              'orient', 'auto').attr('style', 'stroke: none; fill: gray');
          } else {
            runtimeGroup.append('circle').attr('cx', rectOriginX + this.width - 17).attr('cy', rectOriginY + 16).attr('r', '12')
              .attr('orient', 'auto').attr('style', 'stroke: none; fill: orange');
          }
        } else {
          //unknown status
          this.drawRuntimeCount(runtimeGroup, 'runtime-count-unknown', rectOriginX, currentY, '\uf110');
          runtimeGroup.append('circle').attr('cx', rectOriginX + this.width - 17).attr('cy', rectOriginY + 16).attr('r', '12').attr(
            'orient', 'auto').attr('style', 'stroke: none; fill: gray');
        }

        // draw the instance count at good size
        runtimeGroup = commonNodeRendererService.appendCount(runtimeGroup, nodeInstancesCount, deletedCount, rectOriginX, rectOriginY, 20, 20, this.width);
      },

      drawRuntimeCount: function(runtimeGroup, id, rectOriginX, currentY, iconCode, count, instanceCount) {
        var groupSelection = runtimeGroup.select('#' + id);
        // improve that...
        var counter = (count || '?') + '/' + (instanceCount || '?');
        if (groupSelection.empty()) {
          groupSelection = runtimeGroup.append('g').attr('id', id);
          groupSelection.append('text').attr('class', 'topology-svg-icon').attr('text-anchor', 'start').attr('x', rectOriginX + 60).attr('y', currentY).text(iconCode);
          groupSelection.append('text').attr('id', 'count-text').attr('text-anchor', 'start').attr('x', rectOriginX + 80).attr('y', currentY).text(counter);
        } else {
          groupSelection.select('#count-text').text(counter);
        }
      },

      // common services
      removeRuntimeCount: commonNodeRendererService.removeRuntimeCount,
      getNumberOfInstanceByStatus: commonNodeRendererService.getNumberOfInstanceByStatus,
      tooltip: commonNodeRendererService.tooltip
    };
  } // function
]);


text:
package com.mossle.bridge.userauth;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import com.mossle.api.scope.ScopeConnector;
import com.mossle.api.scope.ScopeDTO;
import com.mossle.api.user.UserConnector;
import com.mossle.api.user.UserDTO;
import com.mossle.api.userauth.UserAuthConnector;
import com.mossle.api.userauth.UserAuthDTO;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.dao.EmptyResultDataAccessException;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.util.Assert;

public class DatabaseUserAuthConnector implements UserAuthConnector {
    private static Logger logger = LoggerFactory
            .getLogger(DatabaseUserAuthConnector.class);
    private JdbcTemplate jdbcTemplate;
    private ScopeConnector scopeConnector;
    private UserConnector userConnector;

    // ~
    private String sqlFindPassword = "select password from USER_BASE where id=?";
    private String sqlFindPermissions = "select p.code as permission"
            + " from AUTH_USER_STATUS us,AUTH_USER_ROLE ur,AUTH_ROLE r,AUTH_PERM_ROLE_DEF pr,AUTH_PERM p"
            + " where us.id=ur.user_status_id and ur.role_id=r.id and r.role_def_id=pr.role_def_id and pr.perm_id=p.id"
            + " and us.ref=? and us.scope_id=?";
    private String sqlFindRoles = "select r.name as role"
            + " from AUTH_USER_STATUS us,AUTH_USER_ROLE ur,AUTH_ROLE r"
            + " where us.id=ur.user_status_id and ur.role_id=r.id"
            + " and us.ref=? and us.scope_id=?";

    public UserAuthDTO findByUsername(String username, String scopeId) {
        ScopeDTO scopeDto = scopeConnector.findById(scopeId);
        UserDTO userDto = userConnector.findByUsername(username,
                scopeDto.getUserRepoRef());
        Assert.notNull(userDto, "cannot find user by (" + username + ","
                + scopeId + ")");

        return process(userDto, scopeDto, true);
    }

    public UserAuthDTO findByRef(String ref, String scopeId) {
        ScopeDTO scopeDto = scopeConnector.findById(scopeId);
        UserDTO userDto = userConnector.findByRef(ref,
                scopeDto.getUserRepoRef());

        return process(userDto, scopeDto, false);
    }

    public UserAuthDTO findById(String id, String scopeId) {
        ScopeDTO scopeDto = scopeConnector.findById(scopeId);
        UserDTO userDto = userConnector.findById(id);

        return process(userDto, scopeDto, false);
    }

    public UserAuthDTO process(UserDTO userDto, ScopeDTO scopeDto,
            boolean needPassword) {
        UserAuthDTO userAuthDto = new UserAuthDTO();
        userAuthDto.setId(userDto.getId());
        userAuthDto.setScopeId(scopeDto.getId());
        userAuthDto.setUsername(userDto.getUsername());
        userAuthDto.setRef(userDto.getRef());
        userAuthDto.setDisplayName(userDto.getDisplayName());
        userAuthDto.setStatus(Integer.toString(userDto.getStatus()));

        // password
        if (needPassword) {
            String password = jdbcTemplate.queryForObject(sqlFindPassword,
                    String.class, userDto.getId());
            userAuthDto.setPassword(password);
        }

        // permissions
        List<Map<String, Object>> permissions = jdbcTemplate.queryForList(
                sqlFindPermissions, userDto.getId(), scopeDto.getId());
        userAuthDto.setPermissions(this.convertMapListToStringList(permissions,
                "permission"));

        // roles
        List<Map<String, Object>> roles = jdbcTemplate.queryForList(
                sqlFindRoles, userDto.getId(), scopeDto.getId());
        userAuthDto.setRoles(this.convertMapListToStringList(roles, "role"));

        return userAuthDto;
    }

    public List<String> convertMapListToStringList(
            List<Map<String, Object>> mapList, String name) {
        List<String> stringList = new ArrayList<String>();

        for (Map<String, Object> map : mapList) {
            Object value = map.get(name);

            if (value != null) {
                stringList.add(value.toString());
            }
        }

        return stringList;
    }

    public void setScopeConnector(ScopeConnector scopeConnector) {
        this.scopeConnector = scopeConnector;
    }

    public void setUserConnector(UserConnector userConnector) {
        this.userConnector = userConnector;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void setSqlFindPassword(String sqlFindPassword) {
        this.sqlFindPassword = sqlFindPassword;
    }

    public void setSqlFindPermission(String sqlFindPermissions) {
        this.sqlFindPermissions = sqlFindPermissions;
    }

    public void setSqlFindRole(String sqlFindRoles) {
        this.sqlFindRoles = sqlFindRoles;
    }
}


text:
title:  Novi obstoj
date:   21/12/2020
---

Obriše vse solze z njihovih oči; in smrti ne bo več, ne žalovanja ne vpitja ne bolečine ne bo več; kajti prvo je prešlo. Raz 21,4

`Kaj to besedilo pove o tem, kako drugačno bo naše novo življenje?`

Neki kristjan se je s prijateljem pogovarjal o upanju evangelija – o obljubi večnega življenja po Jezusu Kristusu. Prijatelj se je na to zamisel negativno odzval. »Večno življenje?« se je zmrazil. »Kako grozljiva zamisel! Naših 70 ali 80 let je dovolj neprijetnih. Kdo bi si želel to podaljšati v neskončnost? To bi bil pekel!«

Te besede bi lahko bile smiselne, vendar ta oseba ni razumela, da obljuba večnega življenja ne pomeni zgolj nadaljevanja tega življenja. Le kdo bi si to želel? Zgornje besedilo pravi, da bodo stare stvari minile in bo vse postalo novo.

`Kaj naslednja besedila povedo o novem življenju, ki nas čaka? 2 Pt 3,10–13, Raz 21,1–6`

`Pomembno si je zastaviti vprašanje: Kako lahko dobimo novo življenje? Kako smo lahko prepričani, da ga bomo dobili? Katere stvari v našem življenju, če sploh katere, nas lahko ovirajo pri tem, da postanemo deležni obljube, ki nam jo je po Jezusu dal Bog?`