text:
'use strict';

const models = require('./index');

/**
 * Defines an organization.
 *
 * @extends models['Thing']
 */
class Organization extends models['Thing'] {
  /**
   * Create a Organization.
   */
  constructor() {
    super();
  }

  /**
   * Defines the metadata of Organization
   *
   * @returns {object} metadata of Organization
   *
   */
  mapper() {
    return {
      required: false,
      serializedName: 'Organization',
      type: {
        name: 'Composite',
        polymorphicDiscriminator: {
          serializedName: '_type',
          clientName: '_type'
        },
        uberParent: 'ResponseBase',
        className: 'Organization',
        modelProperties: {
          _type: {
            required: true,
            serializedName: '_type',
            type: {
              name: 'String'
            }
          },
          id: {
            required: false,
            readOnly: true,
            serializedName: 'id',
            type: {
              name: 'String'
            }
          },
          contractualRules: {
            required: false,
            readOnly: true,
            serializedName: 'contractualRules',
            type: {
              name: 'Sequence',
              element: {
                  required: false,
                  serializedName: 'ContractualRulesContractualRuleElementType',
                  type: {
                    name: 'Composite',
                    polymorphicDiscriminator: {
                      serializedName: '_type',
                      clientName: '_type'
                    },
                    uberParent: 'ContractualRulesContractualRule',
                    className: 'ContractualRulesContractualRule'
                  }
              }
            }
          },
          webSearchUrl: {
            required: false,
            readOnly: true,
            serializedName: 'webSearchUrl',
            type: {
              name: 'String'
            }
          },
          name: {
            required: false,
            readOnly: true,
            serializedName: 'name',
            type: {
              name: 'String'
            }
          },
          url: {
            required: false,
            readOnly: true,
            serializedName: 'url',
            type: {
              name: 'String'
            }
          },
          image: {
            required: false,
            readOnly: true,
            serializedName: 'image',
            type: {
              name: 'Composite',
              polymorphicDiscriminator: {
                serializedName: '_type',
                clientName: '_type'
              },
              uberParent: 'ResponseBase',
              className: 'ImageObject'
            }
          },
          description: {
            required: false,
            readOnly: true,
            serializedName: 'description',
            type: {
              name: 'String'
            }
          },
          entityPresentationInfo: {
            required: false,
            readOnly: true,
            serializedName: 'entityPresentationInfo',
            type: {
              name: 'Composite',
              className: 'EntitiesEntityPresentationInfo'
            }
          },
          bingId: {
            required: false,
            readOnly: true,
            serializedName: 'bingId',
            type: {
              name: 'String'
            }
          }
        }
      }
    };
  }
}

module.exports = Organization;


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <title>vue-readme</title>

    <link rel="stylesheet" href="https://unpkg.com/purecss@0.6.2/build/pure-min.css" integrity="sha384-UQiGfs9ICog+LwheBSRCt1o5cbyKIHbwjWscjemyBMT9YCUMZffs6UqUTd0hObXD" crossorigin="anonymous">
    <link rel="stylesheet" href="https://unpkg.com/purecss@0.6.2/build/grids-responsive-min.css">

redpajama_set_name: RedPajamaGithub


text:
<component name="libraryTable">
  <library name="Gradle">
    <CLASSES>
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-tooling-api-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-core-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-messaging-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-model-core-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-model-groovy-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-wrapper-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-base-services-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-base-services-groovy-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-native-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-resources-2.13.jar!/" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-cli-2.13.jar!/" />
    </CLASSES>
    <JAVADOC />
    <SOURCES>
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/tooling-api/src/main/java" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/core/src/main/groovy" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/model-core/src/main/java" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/model-groovy/src/main/java" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/messaging/src/main/java" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/wrapper/src/main/java" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/base-services/src/main/java" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/base-services-groovy/src/main/groovy" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/native/src/main/java" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/resources/src/main/java" />
      <root url="jar://$PROJECT_DIR$/plugins/gradle/lib/gradle-2.13-src.zip!/gradle-2.13/subprojects/cli/src/main/java" />
    </SOURCES>
  </library>
</component>


text:
package scene

import (
	"errors"
	"image"
	"testing"

	"github.com/oakmound/oak/v4/oakerr"
)

func TestMap(t *testing.T) {
	m := NewMap()
	_, ok := m.Get("badScene")
	if ok {
		t.Fatalf("get on an undefined scene should fail")
	}
	if err := m.AddScene("test", Scene{}); err != nil {
		t.Fatalf("scene add should succeed, got %v", err)
	}

	err := m.AddScene("test", Scene{})
	if err == nil {
		t.Fatalf("duplicate scene add should fail")
	}
	exists := &oakerr.ExistingElement{}
	if !errors.As(err, exists) {
		t.Fatalf("expected ExistingElement error type, got %T", err)
	}
	if exists.InputName != "test" {
		t.Fatalf("expected error input 'test', got %q", exists.InputName)
	}
	if exists.InputType != "scene" {
		t.Fatalf("expected error input type 'scene', got %q", exists.InputType)
	}

	_, ok = m.Get("test")
	if !ok {
		t.Fatalf("getting test scene failed")
	}
	m.CurrentScene = "test"
	_, ok = m.GetCurrent()
	if !ok {
		t.Fatalf("getting current test scene failed")
	}
}

func TestFade(t *testing.T) {
	fadeFn := Fade(1, 10)
	if fadeFn(nil, 11) {
		t.Fatalf("fade should not proceed after its frames have elapsed")
	}
	if !fadeFn(image.NewRGBA(image.Rect(0, 0, 50, 50)), 2) {
		t.Fatalf("fade should proceed before its frames have elapsed")
	}
}

func TestZoom(t *testing.T) {
	zoomFn := Zoom(.5, .5, 10, .1)
	if zoomFn(nil, 11) {
		t.Fatalf("zoom should not proceed after its frames have elapsed")
	}
	if !zoomFn(image.NewRGBA(image.Rect(0, 0, 50, 50)), 2) {
		t.Fatalf("zoom should proceed before its frames have elapsed")
	}
}

func TestAddScene(t *testing.T) {
	m := NewMap()
	_, ok := m.Get("badScene")
	if ok {
		t.Fatalf("unexpected success getting undefined scene")
	}

	m.AddScene("test1", Scene{})
	test1, ok := m.Get("test1")
	if !ok {
		t.Fatalf("getting test scene failed")
	}

	eStr, _ := test1.End()
	if eStr != "test1" {
		t.Fatalf("looping test end did not return test1, got %v", eStr)
	}
	test1.Start(&Context{PreviousScene: "test"})
}


text:
require "minitest/autorun"
require "i18n_yaml_editor"

class MiniTest::Unit::TestCase
  include I18nYamlEditor
end


text:
package org.jbpm.formModeler.core.processing.formProcessing;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.jbpm.formModeler.api.client.FormRenderContextManager;
import org.jbpm.formModeler.api.model.Form;
import org.jbpm.formModeler.core.FieldHandlersManager;
import org.jbpm.formModeler.core.processing.FormProcessor;

import javax.inject.Inject;
import java.util.Arrays;
import java.util.Collection;

public abstract class FormChangeProcessor {

    public static final int MAX_ELEMENTS_TO_SHOW = 20;

    private FormChangeProcessor nextProcessor;
    FormProcessingContext context;

    protected String[] supportedFormModes;
    protected String[] sizeRestrictedFormModes;

    @Inject
    protected FieldHandlersManager fieldHandlersManager;

    @Inject
    protected FormProcessor formProcessor;

    @Inject
    protected FormulaReplacementManager replacementManager;

    @Inject
    FormRenderContextManager formRenderContextManager;

    public FormChangeProcessor getNextProcessor() {
        return nextProcessor;
    }

    public void setNextProcessor(FormChangeProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    public FormChangeResponse process(Form form, String namespace, FormChangeResponse response) {
        return process(FormProcessingContext.fullProcessingContext(form, namespace, null), response);
    }

    public FormChangeResponse process(Form form, String namespace, String formMode, FormChangeResponse response) {
        return process(FormProcessingContext.fullProcessingContext(form, namespace, formMode), response);
    }

    public FormChangeResponse process(FormProcessingContext context, FormChangeResponse response) {
        if (canProcess(context)) {
            this.context = context;
            response = doProcess(response);
        }
        if (nextProcessor != null) {
            response = nextProcessor.process(context, response);
        }
        return response;
    }

    public abstract FormChangeResponse doProcess(FormChangeResponse response);

    public abstract int getSupportedContextType();

    public boolean canProcess(FormProcessingContext context) {

        //WM workaround to avoid formulas calculation null pointer when the task has been closed
        if (formRenderContextManager.getRootContext(context.getNamespace()) == null) return false;

        if (!context.isFull() && context.getType() != getSupportedContextType()) return false;

        if (StringUtils.isEmpty(context.getFormMode()) || getSupportedFormModes() == null || getSupportedFormModes().length == 0)
            return true;
        return Arrays.asList(getSupportedFormModes()).contains(context.getFormMode());
    }

    public String[] getSupportedFormModes() {
        return supportedFormModes;
    }

    public void setSupportedFormModes(String[] supportedFormModes) {
        this.supportedFormModes = supportedFormModes;
    }

    public boolean restrictCombosSize(String formMode) {
        if (StringUtils.isEmpty(formMode) || getSizeRestrictedFormModes() == null || getSizeRestrictedFormModes().length == 0) return false;
        return Arrays.asList(getSizeRestrictedFormModes()).contains(formMode);
    }

    public String[] getSizeRestrictedFormModes() {
        return sizeRestrictedFormModes;
    }

    public void setSizeRestrictedFormModes(String[] sizeRestrictedFormModes) {
        this.sizeRestrictedFormModes = sizeRestrictedFormModes;
    }

    public int getMaxElementsToShow(Object[] items, String formMode) {
        return getMaxElementsToShow(Arrays.asList(items), formMode);
    }

    public int getMaxElementsToShow(Collection items, String formMode) {
        if (items == null) return 0;
        if (!restrictCombosSize(formMode)) return items.size();
        return items.size() < MAX_ELEMENTS_TO_SHOW ? items.size() : MAX_ELEMENTS_TO_SHOW;
    }

    protected Collection getEvaluableFields() {
        Collection fields = getContextEvaluableFields();

        if (CollectionUtils.isEmpty(fields)) fields = context.getForm().getFieldNames();

        return fields;
    }

    protected Collection getContextEvaluableFields() {
        switch (getSupportedContextType()) {
            case FormProcessingContext.TYPE_FORMULA: return context.getFieldsToEvaluateFormula();
            case FormProcessingContext.TYPE_DEFAULT_FORMULA: return context.getFieldsToEvaluateDefaultFormula();
            case FormProcessingContext.TYPE_RANGE: return context.getFieldsToEvaluateRange();
            case FormProcessingContext.TYPE_STYLE: return context.getFieldsToEvaluateStyle();
        }
        return null;
    }
}


text:
package org.apache.camel.language.xpath;

import javax.xml.xpath.XPathFactory;

import org.apache.camel.component.mock.MockEndpoint;
import org.apache.camel.test.spring.CamelSpringTestSupport;
import org.junit.Test;
import org.springframework.context.support.AbstractXmlApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Tests that verify the usage of default settings in the XPath language by declaring a bean called xpath in the registry
 */
public class XPathLanguageDefaultSettingsTest extends CamelSpringTestSupport {

    private static final String KEY = XPathFactory.DEFAULT_PROPERTY_NAME + ":" + "http://java.sun.com/jaxp/xpath/dom";
    private boolean jvmAdequate = true;
    private String oldPropertyValue;

    @Override
    public void setUp() throws Exception {
        if (!isJavaVendor("ibm")) {
            // Force using the JAXP default implementation, because having Saxon in the classpath will automatically make JAXP use it
            // because of Service Provider discovery (this does not happen in OSGi because the META-INF/services package is not exported
            oldPropertyValue = System.setProperty(KEY, "com.sun.org.apache.xpath.internal.jaxp.XPathFactoryImpl");
        } else {
            jvmAdequate = false;
        }
        super.setUp();
    }

    @Override
    public void tearDown() throws Exception {
        if (oldPropertyValue != null) {
            System.setProperty(KEY, oldPropertyValue);
        } else {
            System.clearProperty(KEY);
        }
        super.tearDown();
    }

    @Override
    protected AbstractXmlApplicationContext createApplicationContext() {
        return new ClassPathXmlApplicationContext("org/apache/camel/language/xpath/XPathLanguageDefaultSettingsTest.xml");
    }

    @Test
    public void testSpringDSLXPathLanguageDefaultSettings() throws Exception {
        if (!jvmAdequate) {
            return;
        }

        MockEndpoint mockEndpointResult = getMockEndpoint("mock:testDefaultXPathSettingsResult");
        MockEndpoint mockEndpointException = getMockEndpoint("mock:testDefaultXPathSettingsResultException");

        mockEndpointResult.expectedMessageCount(1);
        mockEndpointException.expectedMessageCount(0);

        template.sendBody("seda:testDefaultXPathSettings", "Hello|there|Camel");

        assertMockEndpointsSatisfied();
    }

}


text:
var fontnik = require('fontnik')
var Protobuf = require('pbf')
var parse = require('./lib/parse')

// Currently this seems hard-coded into fontnik
var PADDING = 3

module.exports = extract

function extract (buffer, opt, cb) {
  if (typeof opt === 'function') {
    cb = opt
    opt = {}
  }
  opt = opt || {}

  // default to ASCII 0-255
  var start = opt.start || 0
  var end = typeof opt.end === 'number' ? opt.end : 255

  // load font meta data
  load(buffer, function (err, data) {
    if (err) return cb(err)
    range(buffer, { start: start, end: end }, function (err, ranges) {
      if (err) return cb(err)
      data.glyphs = ranges.glyphs
      cb(null, data)
    })
  })
}

// internal for now

function range (buffer, opt, cb) {
  var start = opt.start
  var end = opt.end

  fontnik.range({
    start: start,
    end: end,
    font: buffer
  }, function (err, data) {
    if (err) return cb(err)

    var pbuf = new Protobuf(new Uint8Array(data))
    var stacks = parse(pbuf, PADDING)
    if (stacks.length > 1) {
      return cb(new Error('multiface not yet supported'))
    }
    cb(null, stacks[0])
  })
}

function load (buffer, cb) {
  fontnik.load(buffer, function (err, data) {
    if (err) return cb(err)

    if (data.length > 1) {
      return cb(new Error('multiface not yet supported'))
    }
    data = data[0]
    cb(null, {
      points: data.points,
      style: data.style_name,
      family: data.family_name,
      padding: PADDING
    })
  })
}


text:
#ifndef SOCKET_UTIL_H__
#define SOCKET_UTIL_H__

#include <erl_nif.h>
#include "socket_int.h"

#define CHAR(C)  ((char) (C))
#define UCHAR(C) ((unsigned char) (C))
#define INT(I)   ((int)   (I))
#define UINT(U)  ((unsigned int) (U))
#define LONG(L)  ((long) (L))
#define ULONG(L) ((unsigned long) (L))
#define SZT(I)   ((size_t) (I))
#define VOIDP(P) ((void*) (P))
#define CHARP(P) ((char*) (P))

#define ESOCK_ABORT(E)  esock_abort(E, __func__, __FILE__, __LINE__)
#define ESOCK_ASSERT(e) ((void) ((e) ? 1 : (ESOCK_ABORT(#e), 0)))

extern
char* esock_encode_iov(ErlNifEnv*    env,
                       int           read,
                       struct iovec* iov,
                       size_t        len,
                       ErlNifBinary* data,
                       ERL_NIF_TERM* eIOV);
extern
char* esock_decode_iov(ErlNifEnv*    env,
                       ERL_NIF_TERM  eIOV,
                       ErlNifBinary* bufs,
                       struct iovec* iov,
                       size_t        len,
                       ssize_t*      totSize);
extern
char* esock_decode_sockaddr(ErlNifEnv*    env,
                            ERL_NIF_TERM  eSockAddr,
                            ESockAddress* sockAddrP,
                            unsigned int* addrLen);
extern
char* esock_encode_sockaddr(ErlNifEnv*    env,
                            ESockAddress* sockAddrP,
                            unsigned int  addrLen,
                            ERL_NIF_TERM* eSockAddr);

extern
char* esock_decode_sockaddr_in4(ErlNifEnv*          env,
                                ERL_NIF_TERM        eSockAddr,
                                struct sockaddr_in* sockAddrP,
                                unsigned int*       addrLen);
extern
char* esock_encode_sockaddr_in4(ErlNifEnv*          env,
                                struct sockaddr_in* sockAddrP,
                                unsigned int        addrLen,
                                ERL_NIF_TERM*       eSockAddr);

#if defined(HAVE_IN6) && defined(AF_INET6)
extern
char* esock_decode_sockaddr_in6(ErlNifEnv*           env,
                                ERL_NIF_TERM         eSockAddr,
                                struct sockaddr_in6* sockAddrP,
                                unsigned int*        addrLen);
extern
char* esock_encode_sockaddr_in6(ErlNifEnv*           env,
                                struct sockaddr_in6* sockAddrP,
                                unsigned int         addrLen,
                                ERL_NIF_TERM*        eSockAddr);
#endif

#ifdef HAVE_SYS_UN_H
extern
char* esock_decode_sockaddr_un(ErlNifEnv*          env,
                               ERL_NIF_TERM        eSockAddr,
                               struct sockaddr_un* sockAddrP,
                               unsigned int*       addrLen);
extern
char* esock_encode_sockaddr_un(ErlNifEnv*          env,
                               struct sockaddr_un* sockAddrP,
                               unsigned int        addrLen,
                               ERL_NIF_TERM*       eSockAddr);
#endif

extern
char* esock_decode_ip4_address(ErlNifEnv*      env,
                               ERL_NIF_TERM    eAddr,
                               struct in_addr* inAddrP);
extern
char* esock_encode_ip4_address(ErlNifEnv*      env,
                               struct in_addr* addrP,
                               ERL_NIF_TERM*   eAddr);

#if defined(HAVE_IN6) && defined(AF_INET6)
extern
char* esock_decode_ip6_address(ErlNifEnv*       env,
                               ERL_NIF_TERM     eAddr,
                               struct in6_addr* inAddrP);
extern
char* esock_encode_ip6_address(ErlNifEnv*       env,
                               struct in6_addr* addrP,
                               ERL_NIF_TERM*    eAddr);
#endif

extern char* esock_encode_timeval(ErlNifEnv*      env,
                                  struct timeval* timeP,
                                  ERL_NIF_TERM*   eTime);
extern char* esock_decode_timeval(ErlNifEnv*      env,
                                  ERL_NIF_TERM    eTime,
                                  struct timeval* timeP);
extern
char* esock_decode_domain(ErlNifEnv*   env,
                          ERL_NIF_TERM eDomain,
                          int*         domain);
extern
char* esock_encode_domain(ErlNifEnv*    env,
                          int           domain,
                          ERL_NIF_TERM* eDomain);

extern
char* esock_decode_type(ErlNifEnv*   env,
                        ERL_NIF_TERM eType,
                        int*         type);
extern
char* esock_encode_type(ErlNifEnv*    env,
                        int           type,
                        ERL_NIF_TERM* eType);

extern
char* esock_decode_protocol(ErlNifEnv*   env,
                            ERL_NIF_TERM eProtocol,
                            int*         protocol);
extern
char* esock_encode_protocol(ErlNifEnv*    env,
                            int           type,
                            ERL_NIF_TERM* eProtocol);

extern
char* esock_decode_bufsz(ErlNifEnv*   env,
                         ERL_NIF_TERM eVal,
                         size_t       defSz,
                         size_t*      sz);

extern
BOOLEAN_T esock_decode_string(ErlNifEnv*         env,
                              const ERL_NIF_TERM eString,
                              char**             stringP);

extern
BOOLEAN_T esock_extract_bool_from_map(ErlNifEnv*   env,
                                      ERL_NIF_TERM map,
                                      ERL_NIF_TERM key,
                                      BOOLEAN_T    def);
extern
BOOLEAN_T esock_decode_bool(ERL_NIF_TERM val);
extern
ERL_NIF_TERM esock_encode_bool(BOOLEAN_T val);

extern
size_t esock_strnlen(const char *s, size_t maxlen);
extern
void esock_abort(const char* expr,
                 const char* func,
                 const char* file,
                 int         line);

extern
ERL_NIF_TERM esock_make_ok2(ErlNifEnv* env, ERL_NIF_TERM any);
extern
ERL_NIF_TERM esock_make_ok3(ErlNifEnv* env, ERL_NIF_TERM val1, ERL_NIF_TERM val2);

extern
ERL_NIF_TERM esock_make_error(ErlNifEnv* env, ERL_NIF_TERM reason);
extern
ERL_NIF_TERM esock_make_error_str(ErlNifEnv* env, char* reason);
extern
ERL_NIF_TERM esock_make_error_errno(ErlNifEnv* env, int err);

extern
BOOLEAN_T esock_timestamp(char *buf, unsigned int len);

extern
void esock_warning_msg(const char* format, ... );

#endif // SOCKET_UTIL_H__


text:
import makeActionCreator from "./creator"
import {
	PAGES_REQUEST,
	PAGES_SUCCESS,
	PAGES_FAILURE,
	PAGEIDS_SELECTED_ADD_REMOVE
} from "./types"

// Action Creators
export const pagesRequest = makeActionCreator(
	PAGES_REQUEST
)
export const pagesSuccess = makeActionCreator(
	PAGES_SUCCESS
)
export const pagesFailure = makeActionCreator(
	PAGES_FAILURE
)
export const selectedPageIDsAddRemove = makeActionCreator(
	PAGEIDS_SELECTED_ADD_REMOVE,
	"ID"
)


text:
package org.agilewiki.jactor2.core.impl;

import com.blockwithme.util.client.UtilEntryPoint;

/**
 * JActor2-Core-St EntryPoint.
 * <p>
 * Basically does nothing, except make sure JActor2-Core is compilable with GWT.
 * </p>
 * @author monster
 */
public class JActor2StEntryPoint implements
        com.google.gwt.core.client.EntryPoint {

    @Override
    public void onModuleLoad() {
        new UtilEntryPoint().onModuleLoad();
    }
}


text:
package de.uni_hildesheim.sse.system.android;

import de.uni_hildesheim.sse.system.IScreenDataGatherer;
import android.content.Context;
import android.util.DisplayMetrics;
import android.view.WindowManager;

public class ScreenDataGatherer implements IScreenDataGatherer {

	private Context context = null;

	/**
	 * Returns the physical screen height.
	 *
	 * @return the physical screen height (in pixel) (negative or zero if
	 *         invalid)
	 */
	@Override
	public int getScreenHeight() {
		DisplayMetrics dm = null;
		if (context != null) {
			dm = new DisplayMetrics();
			WindowManager window = (WindowManager) context
					.getSystemService(Context.WINDOW_SERVICE);
			window.getDefaultDisplay().getMetrics(dm);
		}

		if(dm != null) {
			return dm.heightPixels;
		} else {
			return -1;
		}
	}

	/**
	 * Returns the physical screen width.
	 *
	 * @return the physical screen width (in pixel) (negative or zero if
	 *         invalid)
	 */
	@Override
	public int getScreenWidth() {
		DisplayMetrics dm = null;
		if (context != null) {
			dm = new DisplayMetrics();
			WindowManager window = (WindowManager) context
					.getSystemService(Context.WINDOW_SERVICE);
			window.getDefaultDisplay().getMetrics(dm);
		}

		if(dm != null) {
			return dm.widthPixels;
		} else {
			return -1;
		}
	}

	/**
	 * Returns the physical screen resolution.
	 *
	 * @return the physical screen resolution (in dpi) (negative or zero if
	 *         invalid)
	 */
	@Override
	public int getScreenResolution() {
		DisplayMetrics dm = null;
		if (context != null) {
			dm = new DisplayMetrics();
			WindowManager window = (WindowManager) context
					.getSystemService(Context.WINDOW_SERVICE);
			window.getDefaultDisplay().getMetrics(dm);
		}

		if(dm != null) {
			return dm.densityDpi;
		} else {
			return -1;
		}
	}

	/**
	 * Function for setting context.
	 *
	 * @param context
	 */
	public void setContext(Context context) {
		this.context = context;
	}

}


text:
      {{'strong' | translate | lowercase}} {{'or' | translate}} {{'weak' | translate | lowercase}}

      {{'systemProcesses.systemSetup.text2-2-1' | translate}}
       {{'systemProcesses.header.checkSequence' | translate}}
      {{'systemProcesses.systemSetup.text2-2-2' | translate}}

      {{'strong' | translate | lowercase}} / {{'weak' | translate | lowercase}}