git checkout custom_branch && git rebase master

This will update custom_branch with changes from master branch.

Don't forget to make sure master is up to date first. git pull

This is also possible with git checkout custom_branch && git merge master

All parameters to 'git merge' in this case are branches that you're merging from, i.e. source branches. You're always merging to the current branch.

Because origin is a remote name, git automatically expands it to that remote's default branch, so it's actually equivalent to origin/master – the command is being told to merge the same branch twice.

(It is possible to merge more than one branch, known as "octopus merge", but this is rarely done – and when it is done, the branches of course are different.)

As it is, the command doesn't make much sense. Maybe it should have been either git merge origin/master (without the duplication) or git pull origin master.

git merge origin/master can do one of two things (or error).

In the first case, it creates a new commit that has two parents: the current HEAD, and the commit pointed to by the ref origin/master (unless you're doing something funny, this is likely to be (the local pointer to) the branch named master on a remote named origin, though this is completely conventional).

In the second case, where there is no tree-level merge necessary, rather than creating a new commit, it updates the currently checked-out ref to point to the same commit as is pointed to by origin/master. (This is called a fast-forward merge -- git can be directed to either always or never do this when you merge through command-line flags).

It does not call git commit directly, which is a higher-level (porcelain in the git-parlance) command intended for users.

Calling git merge master/original will try and resolve master/original to a commit, which will almost certainly (again, unless you've done something deliberate) not be the same as origin/master. If you happen to have a remote named master that has a branch named original, it will create a new commit which has that as the second parent.

You may find git help rev-parse to be helpful in deciphering how git attempts to resolve ref names or other notations into commits.

git fetch fetches information on remote branches, but does not make any changes to your local master branch. Because of this, master and origin/master are still diverged. You'd have to merge them by using git pull.

When you make a commit, your local master branch is ahead of origin/master until you push those changes. This case is the opposite, where the origin/master branch is ahead of your local master branch. This is why you are getting different outcomes.

Read https://stackoverflow.com/a/7104747/2961170 for more information.

From your feature branch (e.g configUpdate) run:

git fetch
git rebase origin/master

Or the shorter form:

git pull --rebase

Why this works:

• git merge branchname takes new commits from the branch branchname, and adds them to the current branch. If necessary, it automatically adds a "Merge" commit on top.

• git rebase branchname takes new commits from the branch branchname, and inserts them "under" your changes. More precisely, it modifies the history of the current branch such that it is based on the tip of branchname, with any changes you made on top of that.

• git pull is basically the same as git fetch; git merge origin/master.

• git pull --rebase is basically the same as git fetch; git rebase origin/master.

So why would you want to use git pull --rebase rather than git pull? Here's a simple example:

• You start working on a new feature.

• By the time you're ready to push your changes, several commits have been pushed by other developers.

• If you git pull (which uses merge), your changes will be buried by the new commits, in addition to an automatically-created merge commit.

• If you git pull --rebase instead, git will fast forward your master to upstream's, then apply your changes on top.

newbranch should be current branch, to make sure you can checkout it, then you get updated from you repo using fetch and then merge newbranch with master

About checkout: branch, with which you're currently working is already checkout. To switch to another branch you need checkout it. If already you're working with branch you don't need checkout.

git checkout newbranch
git fetch
git merge origin/master

instead merge you can use rebase, in this case last line should be replaced

git rebase origin/master

Merge and rebase just update you branch with information from other branch. Merge get commits from master and add them to your branch. Rebase did the same by a little different way. See Merging vs. Rebasing. For now just forget about rebase, just do merge.

How I would do this

git checkout master
git pull origin master
git merge test
git push origin master

If I have a local branch from a remote one, I don't feel comfortable with merging other branches than this one with the remote. Also I would not push my changes, until I'm happy with what I want to push and also I wouldn't push things at all, that are only for me and my local repository. In your description it seems, that test is only for you? So no reason to publish it.

git always tries to respect yours and others changes, and so will --rebase. I don't think I can explain it appropriately, so have a look at the Git book - Rebasing or git-ready: Intro into rebasing for a little description. It's a quite cool feature